X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-rtnl%2Frtnl-message.c;h=517df611563f057fc96e3721e56343837e305386;hp=85cf55a3cdcc2df8cad09e0d5445512078f82b89;hb=4ebe732c0cdcd9431a5095140bc4189f86508725;hpb=a33dece5f8cce7f1946263bec76068ef84abc07b diff --git a/src/libsystemd-rtnl/rtnl-message.c b/src/libsystemd-rtnl/rtnl-message.c index 85cf55a3c..517df6115 100644 --- a/src/libsystemd-rtnl/rtnl-message.c +++ b/src/libsystemd-rtnl/rtnl-message.c @@ -35,13 +35,16 @@ struct sd_rtnl_message { RefCount n_ref; struct nlmsghdr *hdr; - - struct rtattr *next_rta; - size_t remaining_size; + size_t container_offset; /* offset from hdr to container start */ + size_t next_rta_offset; /* offset from hdr to next rta */ bool sealed:1; }; +#define CURRENT_CONTAINER(m) ((m)->container_offset ? (struct rtattr*)((uint8_t*)(m)->hdr + (m)->container_offset) : NULL) +#define NEXT_RTA(m) ((struct rtattr*)((uint8_t*)(m)->hdr + (m)->next_rta_offset)) +#define UPDATE_RTA(m, new) (m)->next_rta_offset = (uint8_t*)(new) - (uint8_t*)(m)->hdr; + static int message_new(sd_rtnl_message **ret, size_t initial_size) { sd_rtnl_message *m; @@ -68,16 +71,78 @@ 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; +} + +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_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) { + struct rtmsg *rtm; + + rtm = NLMSG_DATA(m->hdr); + + rtm->rtm_dst_len = prefixlen; + + 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, - unsigned char rtm_scope, unsigned char rtm_protocol, - unsigned char rtm_type, unsigned rtm_flags, sd_rtnl_message **ret) { + sd_rtnl_message **ret) { 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(rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL); assert_return(ret, -EINVAL); r = message_new(ret, NLMSG_SPACE(sizeof(struct rtmsg))); @@ -91,25 +156,43 @@ int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family, rtm = NLMSG_DATA((*ret)->hdr); + UPDATE_RTA(*ret, RTM_RTA(rtm)); + rtm->rtm_family = rtm_family; - rtm->rtm_dst_len = rtm_dst_len; - rtm->rtm_src_len = rtm_src_len; - rtm->rtm_tos = rtm_tos; - rtm->rtm_table = rtm_table; - rtm->rtm_protocol = rtm_protocol; - rtm->rtm_scope = rtm_scope; - rtm->rtm_type = rtm_type; - rtm->rtm_flags = rtm_flags; + rtm->rtm_scope = RT_SCOPE_UNIVERSE; + rtm->rtm_type = RTN_UNICAST; + rtm->rtm_table = RT_TABLE_MAIN; + rtm->rtm_protocol = RTPROT_BOOT; + + return 0; +} + +int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags) { + struct ifinfomsg *ifi; + + ifi = NLMSG_DATA(m->hdr); + + ifi->ifi_flags = flags; 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_set_type(sd_rtnl_message *m, unsigned type) { + struct ifinfomsg *ifi; + + ifi = NLMSG_DATA(m->hdr); + + ifi->ifi_type = type; + + return 0; +} + +int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, 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))); @@ -118,15 +201,17 @@ 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); ifi->ifi_family = AF_UNSPEC; ifi->ifi_index = index; - ifi->ifi_type = type; - ifi->ifi_flags = flags; ifi->ifi_change = 0xffffffff; + UPDATE_RTA(*ret, IFLA_RTA(ifi)); + return 0; } @@ -134,7 +219,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); @@ -153,6 +238,8 @@ int sd_rtnl_message_addr_new(uint16_t nlmsg_type, int index, unsigned char famil ifa->ifa_scope = scope; ifa->ifa_index = index; + UPDATE_RTA(*ret, IFA_RTA(ifa)); + return 0; } @@ -181,24 +268,53 @@ int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) { return 0; } -/* If successful the updated message will be correctly aligned, if unsuccessful the old message is - untouched */ +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) { 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); /* realloc to fit the new attribute */ @@ -209,118 +325,255 @@ static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, /* 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; + + /* if we are inside a container, extend it */ + if (CURRENT_CONTAINER(m)) + CURRENT_CONTAINER(m)->rta_len += message_length - m->hdr->nlmsg_len; /* 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 the start of a new container */ + m->container_offset = m->hdr->nlmsg_len; + } 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 */ + memzero(padding, + (uint8_t *) m->hdr + message_length - (uint8_t *) padding); + } + + /* update message size */ + m->hdr->nlmsg_len = message_length; return 0; } -int sd_rtnl_message_append(sd_rtnl_message *m, unsigned short type, const void *data) { +int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data) { uint16_t rtm_type; - struct ifaddrmsg *ifa; - struct rtmsg *rtm; + 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; + /* check that the type is correct */ switch (rtm_type) { case RTM_NEWLINK: + case RTM_SETLINK: + case RTM_GETLINK: case RTM_DELLINK: + if (CURRENT_CONTAINER(m)) { + if (CURRENT_CONTAINER(m)->rta_type != IFLA_LINKINFO || + type != IFLA_INFO_KIND) + return -ENOTSUP; + } else { + switch (type) { + case IFLA_IFNAME: + case IFLA_IFALIAS: + case IFLA_QDISC: + break; + default: + return -ENOTSUP; + } + } + break; + case RTM_NEWADDR: + case RTM_GETADDR: + case RTM_DELADDR: + if (type != IFA_LABEL) + return -ENOTSUP; + break; + default: + return -ENOTSUP; + } + + r = add_rtattr(m, type, data, strlen(data) + 1); + if (r < 0) + return r; + + return 0; +} + +int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data) { + uint16_t rtm_type; + int r; + + assert_return(m, -EINVAL); + + r = sd_rtnl_message_get_type(m, &rtm_type); + if (r < 0) + return r; + + /* check that the type is correct */ + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_SETLINK: case RTM_GETLINK: + case RTM_DELLINK: switch (type) { - case IFLA_IFNAME: - 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: - 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); + break; + default: + return -ENOTSUP; + } + break; + case RTM_NEWROUTE: + case RTM_GETROUTE: + case RTM_DELROUTE: + switch (type) { + case RTA_TABLE: + case RTA_PRIORITY: + case RTA_IIF: + case RTA_OIF: + break; default: return -ENOTSUP; } + break; + default: + return -ENOTSUP; + } + + r = add_rtattr(m, type, &data, sizeof(uint32_t)); + if (r < 0) + return r; + + return 0; +} + +int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data) { + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + uint16_t rtm_type; + int r; + + assert_return(m, -EINVAL); + assert_return(data, -EINVAL); + + r = sd_rtnl_message_get_type(m, &rtm_type); + if (r < 0) + return r; + + /* check that the type is correct */ + switch (rtm_type) { case RTM_NEWADDR: - case RTM_DELADDR: case RTM_GETADDR: + case RTM_DELADDR: 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; - } + + if (ifa->ifa_family != AF_INET) + return -EINVAL; + + break; default: return -ENOTSUP; } + break; case RTM_NEWROUTE: - case RTM_DELROUTE: case RTM_GETROUTE: + case RTM_DELROUTE: switch (type) { case RTA_DST: case RTA_SRC: case RTA_GATEWAY: rtm = NLMSG_DATA(m->hdr); - switch (rtm->rtm_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; - } - case RTA_TABLE: - case RTA_PRIORITY: - case RTA_IIF: - case RTA_OIF: - return add_rtattr(m, type, data, sizeof(uint32_t)); + + if (rtm->rtm_family != AF_INET) + return -EINVAL; + + break; default: return -ENOTSUP; } + break; default: return -ENOTSUP; } + + r = add_rtattr(m, type, data, sizeof(struct in_addr)); + if (r < 0) + return r; + + return 0; } -static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { +int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data) { + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + uint16_t rtm_type; + int r; + assert_return(m, -EINVAL); assert_return(data, -EINVAL); - if (!RTA_OK(m->next_rta, m->remaining_size)) - return 0; + r = sd_rtnl_message_get_type(m, &rtm_type); + if (r < 0) + return r; - *data = RTA_DATA(m->next_rta); - *type = m->next_rta->rta_type; + /* check that the type is correct */ + switch (rtm_type) { + case RTM_NEWADDR: + case RTM_GETADDR: + case RTM_DELADDR: + switch (type) { + case IFA_ADDRESS: + case IFA_LOCAL: + case IFA_BROADCAST: + case IFA_ANYCAST: + ifa = NLMSG_DATA(m->hdr); - m->next_rta = RTA_NEXT(m->next_rta, m->remaining_size); + if (ifa->ifa_family != AF_INET6) + return -EINVAL; - return 1; + break; + default: + return -ENOTSUP; + } + break; + case RTM_NEWROUTE: + case RTM_GETROUTE: + case RTM_DELROUTE: + switch (type) { + case RTA_DST: + case RTA_SRC: + case RTA_GATEWAY: + rtm = NLMSG_DATA(m->hdr); + + if (rtm->rtm_family != AF_INET6) + return -EINVAL; + + break; + default: + return -ENOTSUP; + } + default: + return -ENOTSUP; + } + + r = add_rtattr(m, type, data, sizeof(struct in6_addr)); + if (r < 0) + return r; + + return 0; } -int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) { +int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data) { uint16_t rtm_type; + int r; assert_return(m, -EINVAL); assert_return(data, -EINVAL); @@ -329,52 +582,101 @@ int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) switch (rtm_type) { case RTM_NEWLINK: + case RTM_SETLINK: case RTM_DELLINK: case RTM_GETLINK: - if (!m->next_rta) { - struct ifinfomsg *ifi = 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 = NLMSG_DATA(m->hdr); - - m->next_rta = IFA_RTA(ifa); - m->remaining_size = IFA_PAYLOAD(m->hdr); - } - break; - case RTM_NEWROUTE: - case RTM_DELROUTE: - case RTM_GETROUTE: - if (!m->next_rta) { - struct rtmesg *rtm = NLMSG_DATA(m->hdr); - - m->next_rta = RTM_RTA(rtm); - m->remaining_size = RTM_PAYLOAD(m->hdr); + switch (type) { + case IFLA_ADDRESS: + case IFLA_BROADCAST: + break; + default: + return -ENOTSUP; } break; default: return -ENOTSUP; } - return message_read(m, type, data); + r = add_rtattr(m, type, data, ETH_ALEN); + if (r < 0) + return r; + + return 0; +} + +int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) { + uint16_t rtm_type; + + assert_return(m, -EINVAL); + assert_return(!CURRENT_CONTAINER(m), -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(CURRENT_CONTAINER(m), -EINVAL); + + m->container_offset = 0; + + return 0; } -int message_get_serial(sd_rtnl_message *m) { +int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) { + size_t remaining_size; + uint16_t rtm_type; + int r; + assert(m); + assert(m->next_rta_offset); + assert(type); + assert(data); + + remaining_size = m->hdr->nlmsg_len - m->next_rta_offset; + + if (!RTA_OK(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; + + if (message_type_is_link(rtm_type) && + NEXT_RTA(m)->rta_type == IFLA_LINKINFO) + return -EINVAL; + + *data = RTA_DATA(NEXT_RTA(m)); + *type = NEXT_RTA(m)->rta_type; + + UPDATE_RTA(m, RTA_NEXT(NEXT_RTA(m), remaining_size)); + + return 1; +} + +uint32_t message_get_serial(sd_rtnl_message *m) { + assert(m); + assert(m->hdr); 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); + assert_return(m->hdr, -EINVAL); if (m->hdr->nlmsg_type != NLMSG_ERROR) return 0; @@ -385,6 +687,10 @@ int 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; @@ -395,8 +701,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 @@ -424,8 +730,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)); @@ -451,8 +758,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) @@ -478,27 +785,50 @@ 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) { + struct ifinfomsg *ifi; + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + /* 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_SETLINK: case RTM_DELLINK: case RTM_GETLINK: if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) k = -EIO; + else { + ifi = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, IFLA_RTA(ifi)); + } break; case RTM_NEWADDR: case RTM_DELADDR: case RTM_GETADDR: if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifaddrmsg))) k = -EIO; + else { + ifa = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, IFA_RTA(ifa)); + } + break; + case RTM_NEWROUTE: + case RTM_DELROUTE: + case RTM_GETROUTE: + if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtmsg))) + k = -EIO; + else { + rtm = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, RTM_RTA(rtm)); + } break; case NLMSG_NOOP: k = 0; @@ -517,3 +847,41 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { return k; } + +int sd_rtnl_message_rewind(sd_rtnl_message *m) { + struct ifinfomsg *ifi; + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + + assert_return(m, -EINVAL); + assert_return(m->hdr, -EINVAL); + + switch(m->hdr->nlmsg_type) { + case RTM_NEWLINK: + case RTM_SETLINK: + case RTM_GETLINK: + case RTM_DELLINK: + ifi = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, IFLA_RTA(ifi)); + + break; + case RTM_NEWADDR: + case RTM_GETADDR: + case RTM_DELADDR: + ifa = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, IFA_RTA(ifa)); + + break; + case RTM_NEWROUTE: + case RTM_GETROUTE: + case RTM_DELROUTE: + rtm = NLMSG_DATA(m->hdr); + UPDATE_RTA(m, RTM_RTA(rtm)); + + break; + default: + return -ENOTSUP; + } + + return 0; +}