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=06c7622f7c936bf9dd7c9f6077156176d308cc35;hb=4ebe732c0cdcd9431a5095140bc4189f86508725;hpb=a02113d2ea96467dc9f1ec196d5f62a34dd99314 diff --git a/src/libsystemd-rtnl/rtnl-message.c b/src/libsystemd-rtnl/rtnl-message.c index 06c7622f7..517df6115 100644 --- a/src/libsystemd-rtnl/rtnl-message.c +++ b/src/libsystemd-rtnl/rtnl-message.c @@ -35,15 +35,16 @@ struct sd_rtnl_message { RefCount n_ref; struct nlmsghdr *hdr; - - struct rtattr *current_container; - - 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; @@ -91,16 +92,57 @@ 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_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))); @@ -114,25 +156,42 @@ 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_SETLINK || nlmsg_type == RTM_GETLINK, -EINVAL); + assert_return(message_type_is_link(nlmsg_type), -EINVAL); assert_return(nlmsg_type == RTM_NEWLINK || index > 0, -EINVAL); assert_return(ret, -EINVAL); @@ -149,10 +208,10 @@ int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, unsigned int type, 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; } @@ -160,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); @@ -179,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; } @@ -211,9 +272,9 @@ 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); - 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); @@ -222,8 +283,23 @@ int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) { return 0; } -/* If successful the updated message will be correctly aligned, if unsuccessful the old message is - untouched */ +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; @@ -237,8 +313,8 @@ static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, /* 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 at the end) - */ + + /* 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 */ @@ -249,183 +325,326 @@ 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; - /* 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; + /* 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; if (!data) { - /* this is a container, set pointer */ - m->current_container = rta; + /* 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 */ - memset(padding, '\0', (unsigned char *) m->hdr + - m->hdr->nlmsg_len - - (unsigned char *) padding); + 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; - 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; - } + /* 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; } - default: + } + 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_DELLINK: case RTM_GETLINK: + case RTM_DELLINK: 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: 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_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_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; +} + +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); + + 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_GETADDR: + case RTM_DELADDR: + switch (type) { + case IFA_ADDRESS: + case IFA_LOCAL: + case IFA_BROADCAST: + case IFA_ANYCAST: + ifa = NLMSG_DATA(m->hdr); + + if (ifa->ifa_family != AF_INET6) + return -EINVAL; + + 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); - 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_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_open_container(sd_rtnl_message *m, unsigned short type) { +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(!m->current_container, -EINVAL); + assert_return(data, -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; + case RTM_GETLINK: + switch (type) { + case IFLA_ADDRESS: + case IFLA_BROADCAST: + break; + default: + return -ENOTSUP; + } + break; default: return -ENOTSUP; } + 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(m->current_container, -EINVAL); + assert_return(CURRENT_CONTAINER(m), -EINVAL); - m->current_container = NULL; + m->container_offset = 0; return 0; } -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) { + size_t remaining_size; uint16_t rtm_type; int r; assert(m); - assert(m->next_rta); + assert(m->next_rta_offset); assert(type); assert(data); - if (!RTA_OK(m->next_rta, m->remaining_size)) + 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 @@ -434,76 +653,21 @@ static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { 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; - } - } + if (message_type_is_link(rtm_type) && + NEXT_RTA(m)->rta_type == IFLA_LINKINFO) + return -EINVAL; - *data = RTA_DATA(m->next_rta); - *type = m->next_rta->rta_type; + *data = RTA_DATA(NEXT_RTA(m)); + *type = NEXT_RTA(m)->rta_type; - m->next_rta = RTA_NEXT(m->next_rta, m->remaining_size); + UPDATE_RTA(m, RTA_NEXT(NEXT_RTA(m), remaining_size)); return 1; } -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); - - 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) { - 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); - } - break; - default: - return -ENOTSUP; - } - - return message_read(m, type, data); -} - uint32_t message_get_serial(sd_rtnl_message *m) { assert(m); + assert(m->hdr); return m->hdr->nlmsg_seq; } @@ -512,6 +676,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; @@ -522,6 +687,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; @@ -532,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 @@ -561,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)); @@ -588,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) @@ -620,6 +790,10 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { 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))) @@ -631,12 +805,30 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { 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; @@ -655,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; +}