diff --git a/src/libsystemd/sd-netlink/netlink-message-rtnl.c b/src/libsystemd/sd-netlink/netlink-message-rtnl.c index 9184c43fec..29c3af1fec 100644 --- a/src/libsystemd/sd-netlink/netlink-message-rtnl.c +++ b/src/libsystemd/sd-netlink/netlink-message-rtnl.c @@ -60,482 +60,95 @@ static bool rtnl_message_type_is_nsid(uint16_t type) { return IN_SET(type, RTM_NEWNSID, RTM_DELNSID, RTM_GETNSID); } -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_tos(sd_netlink_message *m, unsigned char tos) { - 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_tos = tos; - - 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_set_flags(sd_netlink_message *m, unsigned flags) { - 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_flags = flags; - - return 0; -} - -int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) { - 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(flags, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *flags = rtm->rtm_flags; - - return 0; -} - -int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) { - 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_table = table; - - 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_type(sd_netlink_message *m, unsigned char *type) { - 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(type, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *type = rtm->rtm_type; - - return 0; -} - -int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) { - 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_type = type; - - return 0; -} - -int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol) { - 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(protocol, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *protocol = rtm->rtm_protocol; - - return 0; -} - -int sd_rtnl_message_route_get_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); - assert_return(scope, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *scope = rtm->rtm_scope; - - return 0; -} - -int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) { - 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(tos, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *tos = rtm->rtm_tos; - - return 0; -} - -int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) { - 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(table, -EINVAL); - - rtm = NLMSG_DATA(m->hdr); - - *table = rtm->rtm_table; - - 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) || - IN_SET(rtm_family, AF_INET, 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_protocol = rtm_protocol; - - return 0; -} - -int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, - uint16_t nlmsg_type, int nh_family, - unsigned char nh_protocol) { - struct nhmsg *nhm; - int r; - - assert_return(rtnl_message_type_is_nexthop(nlmsg_type), -EINVAL); - switch (nlmsg_type) { - case RTM_DELNEXTHOP: - assert_return(nh_family == AF_UNSPEC, -EINVAL); - _fallthrough_; - case RTM_GETNEXTHOP: - assert_return(nh_protocol == RTPROT_UNSPEC, -EINVAL); - break; - case RTM_NEWNEXTHOP: - assert_return(IN_SET(nh_family, AF_UNSPEC, AF_INET, AF_INET6), -EINVAL); - break; - default: - assert_not_reached(); - } - assert_return(ret, -EINVAL); - - r = message_new(rtnl, ret, nlmsg_type); - if (r < 0) - return r; - - if (nlmsg_type == RTM_NEWNEXTHOP) - (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; - - nhm = NLMSG_DATA((*ret)->hdr); - - nhm->nh_family = nh_family; - nhm->nh_scope = RT_SCOPE_UNIVERSE; - nhm->nh_protocol = nh_protocol; - - return 0; -} - -int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) { - struct nhmsg *nhm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(m->hdr->nlmsg_type == RTM_NEWNEXTHOP, -EINVAL); - - nhm = NLMSG_DATA(m->hdr); - nhm->nh_flags = flags; - - return 0; -} - -int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) { - struct nhmsg *nhm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_nexthop(m->hdr->nlmsg_type), -EINVAL); - assert_return(ret, -EINVAL); - - nhm = NLMSG_DATA(m->hdr); - *ret = nhm->nh_flags; - - return 0; -} - -int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) { - struct nhmsg *nhm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_nexthop(m->hdr->nlmsg_type), -EINVAL); - assert_return(family, -EINVAL); - - nhm = NLMSG_DATA(m->hdr); - *family = nhm->nh_family; - - return 0; -} - -int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol) { - struct nhmsg *nhm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_nexthop(m->hdr->nlmsg_type), -EINVAL); - assert_return(protocol, -EINVAL); - - nhm = NLMSG_DATA(m->hdr); - *protocol = nhm->nh_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(IN_SET(ndm_family, AF_UNSPEC, AF_INET, AF_INET6, AF_BRIDGE), -EINVAL); - assert_return(ret, -EINVAL); - - r = message_new(rtnl, ret, nlmsg_type); - if (r < 0) - return r; - - if (nlmsg_type == RTM_NEWNEIGH) { - if (ndm_family == AF_BRIDGE) - (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND; - else - (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; +#define DEFINE_RTNL_MESSAGE_SETTER(class, header_type, element, name, value_type) \ + int sd_rtnl_message_##class##_set_##name(sd_netlink_message *m, value_type value) { \ + assert_return(m, -EINVAL); \ + assert_return(m->hdr, -EINVAL); \ + assert_return(rtnl_message_type_is_##class(m->hdr->nlmsg_type), -EINVAL); \ + \ + header_type *hdr = NLMSG_DATA(m->hdr); \ + hdr->element = value; \ + return 0; \ } - ndm = NLMSG_DATA((*ret)->hdr); +#define DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(class, header_type, family_element, element, name, value_type) \ + int sd_rtnl_message_##class##_set_##name(sd_netlink_message *m, value_type value) { \ + assert_return(m, -EINVAL); \ + assert_return(m->hdr, -EINVAL); \ + assert_return(rtnl_message_type_is_##class(m->hdr->nlmsg_type), -EINVAL); \ + \ + header_type *hdr = NLMSG_DATA(m->hdr); \ + \ + if (value > FAMILY_ADDRESS_SIZE_SAFE(hdr->family_element) * 8) \ + return -ERANGE; \ + \ + hdr->element = value; \ + return 0; \ + } - ndm->ndm_family = ndm_family; - ndm->ndm_ifindex = index; +#define DEFINE_RTNL_MESSAGE_ADDR_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(addr, struct ifaddrmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_LINK_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(link, struct ifinfomsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ROUTE_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(route, struct rtmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_NEXTHOP_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(nexthop, struct nhmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_NEIGH_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(neigh, struct ndmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ADDRLABEL_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(addrlabel, struct ifaddrlblmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(routing_policy_rule, struct fib_rule_hdr, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_TRAFFIC_CONTROL_SETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_SETTER(traffic_control, struct tcmsg, element, name, value_type) - return 0; -} +#define DEFINE_RTNL_MESSAGE_GETTER(class, header_type, element, name, value_type) \ + int sd_rtnl_message_##class##_get_##name(sd_netlink_message *m, value_type *ret) { \ + assert_return(m, -EINVAL); \ + assert_return(m->hdr, -EINVAL); \ + assert_return(rtnl_message_type_is_##class(m->hdr->nlmsg_type), -EINVAL); \ + assert_return(ret, -EINVAL); \ + \ + header_type *hdr = NLMSG_DATA(m->hdr); \ + *ret = hdr->element; \ + return 0; \ + } -int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) { +#define DEFINE_RTNL_MESSAGE_ADDR_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(addr, struct ifaddrmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_LINK_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(link, struct ifinfomsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ROUTE_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(route, struct rtmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_NEXTHOP_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(nexthop, struct nhmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_NEIGH_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(neigh, struct ndmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ADDRLABEL_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(addrlabel, struct ifaddrlblmsg, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(routing_policy_rule, struct fib_rule_hdr, element, name, value_type) +#define DEFINE_RTNL_MESSAGE_TRAFFIC_CONTROL_GETTER(element, name, value_type) \ + DEFINE_RTNL_MESSAGE_GETTER(traffic_control, struct tcmsg, element, name, value_type) + +DEFINE_RTNL_MESSAGE_ADDR_GETTER(ifa_index, ifindex, int); +DEFINE_RTNL_MESSAGE_ADDR_GETTER(ifa_family, family, int); +DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(addr, struct ifaddrmsg, ifa_family, ifa_prefixlen, prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ADDR_GETTER(ifa_prefixlen, prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ADDR_SETTER(ifa_flags, flags, uint8_t); +DEFINE_RTNL_MESSAGE_ADDR_GETTER(ifa_flags, flags, uint8_t); +DEFINE_RTNL_MESSAGE_ADDR_SETTER(ifa_scope, scope, uint8_t); +DEFINE_RTNL_MESSAGE_ADDR_GETTER(ifa_scope, scope, uint8_t); + +DEFINE_RTNL_MESSAGE_LINK_GETTER(ifi_index, ifindex, int); +DEFINE_RTNL_MESSAGE_LINK_SETTER(ifi_family, family, int); +DEFINE_RTNL_MESSAGE_LINK_GETTER(ifi_family, family, int); +DEFINE_RTNL_MESSAGE_LINK_SETTER(ifi_type, type, uint16_t); +DEFINE_RTNL_MESSAGE_LINK_GETTER(ifi_type, type, uint16_t); +DEFINE_RTNL_MESSAGE_LINK_GETTER(ifi_flags, flags, uint32_t); + +int sd_rtnl_message_link_set_flags(sd_netlink_message *m, uint32_t flags, uint32_t change) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -551,36 +164,174 @@ int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsign return 0; } -int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) { - struct ifinfomsg *ifi; +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_family, family, int); +DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(route, struct rtmsg, rtm_family, rtm_dst_len, dst_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_dst_len, dst_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(route, struct rtmsg, rtm_family, rtm_src_len, src_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_src_len, src_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_SETTER(rtm_tos, tos, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_tos, tos, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_SETTER(rtm_table, table, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_table, table, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_protocol, protocol, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_SETTER(rtm_scope, scope, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_scope, scope, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_SETTER(rtm_type, type, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_type, type, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTE_SETTER(rtm_flags, flags, uint32_t); +DEFINE_RTNL_MESSAGE_ROUTE_GETTER(rtm_flags, flags, uint32_t); + +DEFINE_RTNL_MESSAGE_NEXTHOP_GETTER(nh_family, family, int); +DEFINE_RTNL_MESSAGE_NEXTHOP_SETTER(nh_flags, flags, uint32_t); +DEFINE_RTNL_MESSAGE_NEXTHOP_GETTER(nh_flags, flags, uint32_t); +DEFINE_RTNL_MESSAGE_NEXTHOP_GETTER(nh_protocol, protocol, uint8_t); + +DEFINE_RTNL_MESSAGE_NEIGH_GETTER(ndm_ifindex, ifindex, int); +DEFINE_RTNL_MESSAGE_NEIGH_GETTER(ndm_family, family, int); +DEFINE_RTNL_MESSAGE_NEIGH_SETTER(ndm_state, state, uint16_t); +DEFINE_RTNL_MESSAGE_NEIGH_GETTER(ndm_state, state, uint16_t); +DEFINE_RTNL_MESSAGE_NEIGH_SETTER(ndm_flags, flags, uint8_t); +DEFINE_RTNL_MESSAGE_NEIGH_GETTER(ndm_flags, flags, uint8_t); + +DEFINE_RTNL_MESSAGE_ADDRLABEL_GETTER(ifal_prefixlen, prefixlen, uint8_t); + +int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, uint8_t prefixlen) { + struct ifaddrlblmsg *addrlabel; assert_return(m, -EINVAL); assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL); + assert_return(rtnl_message_type_is_addrlabel(m->hdr->nlmsg_type), -EINVAL); - ifi = NLMSG_DATA(m->hdr); + addrlabel = NLMSG_DATA(m->hdr); - ifi->ifi_type = type; + if (prefixlen > 128) + return -ERANGE; + + addrlabel->ifal_prefixlen = prefixlen; return 0; } -int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) { - struct ifinfomsg *ifi; +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(family, family, int); +DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(routing_policy_rule, struct fib_rule_hdr, family, dst_len, dst_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(dst_len, dst_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_PREFIXLEN_SETTER(routing_policy_rule, struct fib_rule_hdr, family, src_len, src_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(src_len, src_prefixlen, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_SETTER(tos, tos, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(tos, tos, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_SETTER(table, table, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(table, table, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_SETTER(action, action, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(action, action, uint8_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_SETTER(flags, flags, uint32_t); +DEFINE_RTNL_MESSAGE_ROUTING_POLICY_RULE_GETTER(flags, flags, uint32_t); - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL); +DEFINE_RTNL_MESSAGE_TRAFFIC_CONTROL_GETTER(tcm_ifindex, ifindex, int); +DEFINE_RTNL_MESSAGE_TRAFFIC_CONTROL_GETTER(tcm_handle, handle, uint32_t); +DEFINE_RTNL_MESSAGE_TRAFFIC_CONTROL_GETTER(tcm_parent, parent, uint32_t); - ifi = NLMSG_DATA(m->hdr); +int sd_rtnl_message_new_route( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int family, + uint8_t protocol) { - ifi->ifi_family = family; + struct rtmsg *rtm; + int r; + + assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL); + assert_return((nlmsg_type == RTM_GETROUTE && family == AF_UNSPEC) || + IN_SET(family, AF_INET, 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 = family; + rtm->rtm_protocol = protocol; return 0; } -int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, - uint16_t nlmsg_type, int index) { +int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, + uint16_t nlmsg_type, int family, + uint8_t protocol) { + struct nhmsg *nhm; + int r; + + assert_return(rtnl_message_type_is_nexthop(nlmsg_type), -EINVAL); + switch (nlmsg_type) { + case RTM_DELNEXTHOP: + assert_return(family == AF_UNSPEC, -EINVAL); + _fallthrough_; + case RTM_GETNEXTHOP: + assert_return(protocol == RTPROT_UNSPEC, -EINVAL); + break; + case RTM_NEWNEXTHOP: + assert_return(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6), -EINVAL); + break; + default: + assert_not_reached(); + } + assert_return(ret, -EINVAL); + + r = message_new(rtnl, ret, nlmsg_type); + if (r < 0) + return r; + + if (nlmsg_type == RTM_NEWNEXTHOP) + (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; + + nhm = NLMSG_DATA((*ret)->hdr); + + nhm->nh_family = family; + nhm->nh_scope = RT_SCOPE_UNIVERSE; + nhm->nh_protocol = protocol; + + return 0; +} + +int sd_rtnl_message_new_neigh( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int ifindex, + int family) { + + struct ndmsg *ndm; + int r; + + assert_return(rtnl_message_type_is_neigh(nlmsg_type), -EINVAL); + assert_return(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6, AF_BRIDGE), -EINVAL); + assert_return(ret, -EINVAL); + + r = message_new(rtnl, ret, nlmsg_type); + if (r < 0) + return r; + + if (nlmsg_type == RTM_NEWNEIGH) { + if (family == AF_BRIDGE) + (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND; + else + (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; + } + + ndm = NLMSG_DATA((*ret)->hdr); + + ndm->ndm_family = family; + ndm->ndm_ifindex = ifindex; + + return 0; +} + +int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex) { struct ifinfomsg *ifi; int r; @@ -599,128 +350,7 @@ int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, 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 *ret_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(ret_family, -EINVAL); - - ifa = NLMSG_DATA(m->hdr); - - *ret_family = ifa->ifa_family; - - return 0; -} - -int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *ret_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(ret_prefixlen, -EINVAL); - - ifa = NLMSG_DATA(m->hdr); - - *ret_prefixlen = ifa->ifa_prefixlen; - - return 0; -} - -int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *ret_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(ret_scope, -EINVAL); - - ifa = NLMSG_DATA(m->hdr); - - *ret_scope = ifa->ifa_scope; - - return 0; -} - -int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *ret_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(ret_flags, -EINVAL); - - ifa = NLMSG_DATA(m->hdr); - - *ret_flags = ifa->ifa_flags; - - return 0; -} - -int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ret_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(ret_ifindex, -EINVAL); - - ifa = NLMSG_DATA(m->hdr); - - *ret_ifindex = ifa->ifa_index; + ifi->ifi_index = ifindex; return 0; } @@ -729,15 +359,15 @@ int sd_rtnl_message_new_addr( sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, - int index, + int ifindex, 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 && ifindex == 0) || + ifindex > 0, -EINVAL); assert_return((nlmsg_type == RTM_GETADDR && family == AF_UNSPEC) || IN_SET(family, AF_INET, AF_INET6), -EINVAL); assert_return(ret, -EINVAL); @@ -748,7 +378,7 @@ int sd_rtnl_message_new_addr( ifa = NLMSG_DATA((*ret)->hdr); - ifa->ifa_index = index; + ifa->ifa_index = ifindex; ifa->ifa_family = family; return 0; @@ -757,11 +387,11 @@ int sd_rtnl_message_new_addr( int sd_rtnl_message_new_addr_update( sd_netlink *rtnl, sd_netlink_message **ret, - int index, + int ifindex, int family) { int r; - r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family); + r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, ifindex, family); if (r < 0) return r; @@ -770,106 +400,29 @@ int sd_rtnl_message_new_addr_update( return 0; } -int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) { - struct ifinfomsg *ifi; - +int sd_rtnl_message_get_family(sd_netlink_message *m, int *ret) { 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 short *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_return(ret, -EINVAL); assert(m->hdr); - if (rtnl_message_type_is_link(m->hdr->nlmsg_type)) { - struct ifinfomsg *ifi; + if (rtnl_message_type_is_link(m->hdr->nlmsg_type)) + return sd_rtnl_message_link_get_family(m, ret); - ifi = NLMSG_DATA(m->hdr); + if (rtnl_message_type_is_route(m->hdr->nlmsg_type)) + return sd_rtnl_message_route_get_family(m, ret); - *family = ifi->ifi_family; + if (rtnl_message_type_is_neigh(m->hdr->nlmsg_type)) + return sd_rtnl_message_neigh_get_family(m, ret); - return 0; - } else if (rtnl_message_type_is_route(m->hdr->nlmsg_type)) { - struct rtmsg *rtm; + if (rtnl_message_type_is_addr(m->hdr->nlmsg_type)) + return sd_rtnl_message_addr_get_family(m, ret); - rtm = NLMSG_DATA(m->hdr); + if (rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type)) + return sd_rtnl_message_routing_policy_rule_get_family(m, ret); - *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; - } else if (rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type)) { - struct rtmsg *rtm; - - rtm = NLMSG_DATA(m->hdr); - - *family = rtm->rtm_family; - - return 0; - } else if (rtnl_message_type_is_nexthop(m->hdr->nlmsg_type)) { - struct nhmsg *nhm; - - nhm = NLMSG_DATA(m->hdr); - - *family = nhm->nh_family; - - return 0; - } + if (rtnl_message_type_is_nexthop(m->hdr->nlmsg_type)) + return sd_rtnl_message_nexthop_get_family(m, ret); return -EOPNOTSUPP; } @@ -879,7 +432,7 @@ int sd_rtnl_message_new_addrlabel( sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, - int ifal_family) { + int family) { struct ifaddrlblmsg *addrlabel; int r; @@ -896,48 +449,17 @@ int sd_rtnl_message_new_addrlabel( addrlabel = NLMSG_DATA((*ret)->hdr); - addrlabel->ifal_family = ifal_family; + addrlabel->ifal_family = family; addrlabel->ifal_index = ifindex; return 0; } -int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { - struct ifaddrlblmsg *addrlabel; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_addrlabel(m->hdr->nlmsg_type), -EINVAL); - - addrlabel = NLMSG_DATA(m->hdr); - - if (prefixlen > 128) - return -ERANGE; - - addrlabel->ifal_prefixlen = prefixlen; - - return 0; -} - -int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) { - struct ifaddrlblmsg *addrlabel; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_addrlabel(m->hdr->nlmsg_type), -EINVAL); - - addrlabel = NLMSG_DATA(m->hdr); - - *prefixlen = addrlabel->ifal_prefixlen; - - return 0; -} - int sd_rtnl_message_new_routing_policy_rule( sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, - int ifal_family) { + int family) { struct fib_rule_hdr *frh; int r; @@ -953,173 +475,7 @@ int sd_rtnl_message_new_routing_policy_rule( (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL; frh = NLMSG_DATA((*ret)->hdr); - frh->family = ifal_family; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - frh->tos = tos; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *tos) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - *tos = frh->tos; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - frh->table = table; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *table) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - *table = frh->table; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - frh->flags = flags; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *flags) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - *flags = frh->flags; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint8_t type) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - frh->action = type; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint8_t *type) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - *type = frh->action; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message *m, uint8_t len) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - frh->dst_len = len; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message *m, uint8_t *len) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - *len = frh->dst_len; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message *m, uint8_t len) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - frh->src_len = len; - - return 0; -} - -int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message *m, uint8_t *len) { - struct fib_rule_hdr *frh; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_routing_policy_rule(m->hdr->nlmsg_type), -EINVAL); - - frh = NLMSG_DATA(m->hdr); - - *len = frh->src_len; + frh->family = family; return 0; } @@ -1153,53 +509,11 @@ int sd_rtnl_message_new_traffic_control( return 0; } -int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) { - struct tcmsg *tcm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_traffic_control(m->hdr->nlmsg_type), -EINVAL); - assert_return(ret, -EINVAL); - - tcm = NLMSG_DATA(m->hdr); - *ret = tcm->tcm_ifindex; - - return 0; -} - -int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret) { - struct tcmsg *tcm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_traffic_control(m->hdr->nlmsg_type), -EINVAL); - assert_return(ret, -EINVAL); - - tcm = NLMSG_DATA(m->hdr); - *ret = tcm->tcm_handle; - - return 0; -} - -int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret) { - struct tcmsg *tcm; - - assert_return(m, -EINVAL); - assert_return(m->hdr, -EINVAL); - assert_return(rtnl_message_type_is_traffic_control(m->hdr->nlmsg_type), -EINVAL); - assert_return(ret, -EINVAL); - - tcm = NLMSG_DATA(m->hdr); - *ret = tcm->tcm_parent; - - return 0; -} - int sd_rtnl_message_new_mdb( sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, - int mdb_ifindex) { + int ifindex) { struct br_port_msg *bpm; int r; @@ -1216,7 +530,7 @@ int sd_rtnl_message_new_mdb( bpm = NLMSG_DATA((*ret)->hdr); bpm->family = AF_BRIDGE; - bpm->ifindex = mdb_ifindex; + bpm->ifindex = ifindex; return 0; } diff --git a/src/libsystemd/sd-netlink/netlink-message.c b/src/libsystemd/sd-netlink/netlink-message.c index 25bcbd9640..3df0327444 100644 --- a/src/libsystemd/sd-netlink/netlink-message.c +++ b/src/libsystemd/sd-netlink/netlink-message.c @@ -754,25 +754,55 @@ static int netlink_message_read_internal( return RTA_PAYLOAD(rta); } -int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *data) { +static int netlink_message_read_impl( + sd_netlink_message *m, + uint16_t attr_type, + bool strict, + NLAType type, + size_t size, + void *ret, + bool *ret_net_byteorder) { + + bool net_byteorder; void *attr_data; int r; - assert_return(m, -EINVAL); + assert(m); - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); + if (type >= 0) { + r = message_attribute_has_type(m, NULL, attr_type, type); + if (r < 0) + return r; + } + + r = netlink_message_read_internal(m, attr_type, &attr_data, &net_byteorder); if (r < 0) return r; if ((size_t) r > size) return -ENOBUFS; - if (data) - memcpy(data, attr_data, r); + if (strict && (size_t) r != size) + return -EIO; + + if (ret) + memzero(mempcpy(ret, attr_data, r), size - (size_t) r); + + if (ret_net_byteorder) + *ret_net_byteorder = net_byteorder; return r; } +int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *ret) { + assert_return(m, -EINVAL); + + return netlink_message_read_impl( + m, attr_type, /* strict = */ false, + _NETLINK_TYPE_INVALID, size, + ret, /* ret_net_byteorder = */ NULL); +} + int sd_netlink_message_read_data(sd_netlink_message *m, uint16_t attr_type, size_t *ret_size, void **ret_data) { void *attr_data; int r; @@ -799,34 +829,20 @@ int sd_netlink_message_read_data(sd_netlink_message *m, uint16_t attr_type, size return r; } -int sd_netlink_message_read_string_strdup(sd_netlink_message *m, uint16_t attr_type, char **data) { - void *attr_data; +int sd_netlink_message_read_string_strdup(sd_netlink_message *m, uint16_t attr_type, char **ret) { + const char *s; int r; assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_STRING); + r = sd_netlink_message_read_string(m, attr_type, &s); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; - - if (data) { - char *str; - - str = strndup(attr_data, r); - if (!str) - return -ENOMEM; - - *data = str; - } - - return 0; + return strdup_to(ret, s); } -int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, const char **data) { +int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, const char **ret) { void *attr_data; int r; @@ -843,234 +859,152 @@ int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, co if (strnlen(attr_data, r) >= (size_t) r) return -EIO; - if (data) - *data = (const char *) attr_data; + if (ret) + *ret = (const char *) attr_data; return 0; } -int sd_netlink_message_read_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t *data) { - void *attr_data; - int r; - +int sd_netlink_message_read_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t *ret) { assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U8); - if (r < 0) - return r; - - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; - - if ((size_t) r < sizeof(uint8_t)) - return -EIO; - - if (data) - *data = *(uint8_t *) attr_data; - - return 0; + return netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_U8, sizeof(uint8_t), + ret, /* ret_net_byteorder = */ NULL); } -int sd_netlink_message_read_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t *data) { - void *attr_data; +int sd_netlink_message_read_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t *ret) { bool net_byteorder; + uint16_t u; int r; assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U16); + r = netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_U16, sizeof(uint16_t), + ret ? &u : NULL, &net_byteorder); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, &net_byteorder); - if (r < 0) - return r; - - if ((size_t) r < sizeof(uint16_t)) - return -EIO; - - if (data) { - if (net_byteorder) - *data = be16toh(*(uint16_t *) attr_data); - else - *data = *(uint16_t *) attr_data; - } + if (ret) + *ret = net_byteorder ? be16toh(u) : u; return 0; } -int sd_netlink_message_read_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t *data) { - void *attr_data; +int sd_netlink_message_read_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t *ret) { bool net_byteorder; + uint32_t u; int r; assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U32); + r = netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_U32, sizeof(uint32_t), + ret ? &u : NULL, &net_byteorder); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, &net_byteorder); - if (r < 0) - return r; - - if ((size_t) r < sizeof(uint32_t)) - return -EIO; - - if (data) { - if (net_byteorder) - *data = be32toh(*(uint32_t *) attr_data); - else - *data = *(uint32_t *) attr_data; - } + if (ret) + *ret = net_byteorder ? be32toh(u) : u; return 0; } int sd_netlink_message_read_u64(sd_netlink_message *m, uint16_t attr_type, uint64_t *ret) { - void *attr_data; bool net_byteorder; + uint64_t u; int r; assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_U64); + r = netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_U64, sizeof(uint64_t), + ret ? &u : NULL, &net_byteorder); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, &net_byteorder); - if (r < 0) - return r; - - if ((size_t) r < sizeof(uint64_t)) - return -EIO; - - if (ret) { - if (net_byteorder) - *ret = be64toh(*(uint64_t *) attr_data); - else - *ret = *(uint64_t *) attr_data; - } + if (ret) + *ret = net_byteorder ? be64toh(u) : u; return 0; } -int sd_netlink_message_read_ether_addr(sd_netlink_message *m, uint16_t attr_type, struct ether_addr *data) { - void *attr_data; +int sd_netlink_message_read_ether_addr(sd_netlink_message *m, uint16_t attr_type, struct ether_addr *ret) { + assert_return(m, -EINVAL); + + return netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_ETHER_ADDR, sizeof(struct ether_addr), + ret, /* ret_net_byteorder = */ NULL); +} + +int netlink_message_read_hw_addr(sd_netlink_message *m, uint16_t attr_type, struct hw_addr_data *ret) { int r; assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_ETHER_ADDR); + r = netlink_message_read_impl( + m, attr_type, /* strict = */ false, + NETLINK_TYPE_ETHER_ADDR, HW_ADDR_MAX_SIZE, + ret ? ret->bytes : NULL, /* ret_net_byteorder = */ NULL); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; + if (ret) + ret->length = r; - if ((size_t) r < sizeof(struct ether_addr)) - return -EIO; - - if (data) - memcpy(data, attr_data, sizeof(struct ether_addr)); - - return 0; + return r; } -int netlink_message_read_hw_addr(sd_netlink_message *m, uint16_t attr_type, struct hw_addr_data *data) { - void *attr_data; - int r; - +int sd_netlink_message_read_cache_info(sd_netlink_message *m, uint16_t attr_type, struct ifa_cacheinfo *ret) { assert_return(m, -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_ETHER_ADDR); - if (r < 0) - return r; - - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; - - if (r > HW_ADDR_MAX_SIZE) - return -EIO; - - if (data) { - memcpy(data->bytes, attr_data, r); - data->length = r; - } - - return 0; + return netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_CACHE_INFO, sizeof(struct ifa_cacheinfo), + ret, /* ret_net_byteorder = */ NULL); } -int sd_netlink_message_read_cache_info(sd_netlink_message *m, uint16_t attr_type, struct ifa_cacheinfo *info) { - void *attr_data; - int r; - - assert_return(m, -EINVAL); - - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_CACHE_INFO); - if (r < 0) - return r; - - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; - - if ((size_t) r < sizeof(struct ifa_cacheinfo)) - return -EIO; - - if (info) - memcpy(info, attr_data, sizeof(struct ifa_cacheinfo)); - - return 0; -} - -int netlink_message_read_in_addr_union(sd_netlink_message *m, uint16_t attr_type, int family, union in_addr_union *data) { - void *attr_data; +int netlink_message_read_in_addr_union(sd_netlink_message *m, uint16_t attr_type, int family, union in_addr_union *ret) { int r; assert_return(m, -EINVAL); assert_return(IN_SET(family, AF_INET, AF_INET6), -EINVAL); - r = message_attribute_has_type(m, NULL, attr_type, NETLINK_TYPE_IN_ADDR); + r = netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_IN_ADDR, FAMILY_ADDRESS_SIZE(family), + ret, /* ret_net_byteorder = */ NULL); if (r < 0) return r; - r = netlink_message_read_internal(m, attr_type, &attr_data, NULL); - if (r < 0) - return r; - - if ((size_t) r < FAMILY_ADDRESS_SIZE(family)) - return -EIO; - - if (data) - memcpy(data, attr_data, FAMILY_ADDRESS_SIZE(family)); - - return 0; -} - -int sd_netlink_message_read_in_addr(sd_netlink_message *m, uint16_t attr_type, struct in_addr *data) { - union in_addr_union u; - int r; - - r = netlink_message_read_in_addr_union(m, attr_type, AF_INET, &u); - if (r >= 0 && data) - *data = u.in; + if (ret) + memzero((uint8_t*) ret + FAMILY_ADDRESS_SIZE(family), sizeof(union in_addr_union) - FAMILY_ADDRESS_SIZE(family)); return r; } -int sd_netlink_message_read_in6_addr(sd_netlink_message *m, uint16_t attr_type, struct in6_addr *data) { - union in_addr_union u; - int r; +int sd_netlink_message_read_in_addr(sd_netlink_message *m, uint16_t attr_type, struct in_addr *ret) { + assert_return(m, -EINVAL); - r = netlink_message_read_in_addr_union(m, attr_type, AF_INET6, &u); - if (r >= 0 && data) - *data = u.in6; + return netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_IN_ADDR, sizeof(struct in_addr), + ret, /* ret_net_byteorder = */ NULL); +} - return r; +int sd_netlink_message_read_in6_addr(sd_netlink_message *m, uint16_t attr_type, struct in6_addr *ret) { + assert_return(m, -EINVAL); + + return netlink_message_read_impl( + m, attr_type, /* strict = */ true, + NETLINK_TYPE_IN_ADDR, sizeof(struct in6_addr), + ret, /* ret_net_byteorder = */ NULL); } int sd_netlink_message_has_flag(sd_netlink_message *m, uint16_t attr_type) { @@ -1413,7 +1347,7 @@ void message_seal(sd_netlink_message *m) { m->sealed = true; } -sd_netlink_message *sd_netlink_message_next(sd_netlink_message *m) { +sd_netlink_message* sd_netlink_message_next(sd_netlink_message *m) { assert_return(m, NULL); return m->next; diff --git a/src/libsystemd/sd-netlink/netlink-slot.c b/src/libsystemd/sd-netlink/netlink-slot.c index d85d2cd2f4..e8903b1922 100644 --- a/src/libsystemd/sd-netlink/netlink-slot.c +++ b/src/libsystemd/sd-netlink/netlink-slot.c @@ -105,19 +105,19 @@ static sd_netlink_slot* netlink_slot_free(sd_netlink_slot *slot) { DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_netlink_slot, sd_netlink_slot, netlink_slot_free); -sd_netlink *sd_netlink_slot_get_netlink(sd_netlink_slot *slot) { +sd_netlink* sd_netlink_slot_get_netlink(sd_netlink_slot *slot) { assert_return(slot, NULL); return slot->netlink; } -void *sd_netlink_slot_get_userdata(sd_netlink_slot *slot) { +void* sd_netlink_slot_get_userdata(sd_netlink_slot *slot) { assert_return(slot, NULL); return slot->userdata; } -void *sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata) { +void* sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata) { void *ret; assert_return(slot, NULL); @@ -128,11 +128,11 @@ void *sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata) { return ret; } -int sd_netlink_slot_get_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t *callback) { +int sd_netlink_slot_get_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t *ret) { assert_return(slot, -EINVAL); - if (callback) - *callback = slot->destroy_callback; + if (ret) + *ret = slot->destroy_callback; return !!slot->destroy_callback; } @@ -172,11 +172,11 @@ int sd_netlink_slot_set_floating(sd_netlink_slot *slot, int b) { return 1; } -int sd_netlink_slot_get_description(sd_netlink_slot *slot, const char **description) { +int sd_netlink_slot_get_description(sd_netlink_slot *slot, const char **ret) { assert_return(slot, -EINVAL); - if (description) - *description = slot->description; + if (ret) + *ret = slot->description; return !!slot->description; } diff --git a/src/libsystemd/sd-netlink/sd-netlink.c b/src/libsystemd/sd-netlink/sd-netlink.c index b347ee6339..e6bd69f2de 100644 --- a/src/libsystemd/sd-netlink/sd-netlink.c +++ b/src/libsystemd/sd-netlink/sd-netlink.c @@ -148,7 +148,7 @@ DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_netlink, sd_netlink, netlink_free); int sd_netlink_send( sd_netlink *nl, sd_netlink_message *message, - uint32_t *serial) { + uint32_t *ret_serial) { int r; @@ -163,8 +163,8 @@ int sd_netlink_send( if (r < 0) return r; - if (serial) - *serial = message_get_serial(message); + if (ret_serial) + *ret_serial = message_get_serial(message); return 1; } @@ -626,25 +626,25 @@ int sd_netlink_get_events(sd_netlink *nl) { return ordered_set_isempty(nl->rqueue) ? POLLIN : 0; } -int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout_usec) { +int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *ret) { struct reply_callback *c; assert_return(nl, -EINVAL); - assert_return(timeout_usec, -EINVAL); + assert_return(ret, -EINVAL); assert_return(!netlink_pid_changed(nl), -ECHILD); if (!ordered_set_isempty(nl->rqueue)) { - *timeout_usec = 0; + *ret = 0; return 1; } c = prioq_peek(nl->reply_callbacks_prioq); if (!c) { - *timeout_usec = UINT64_MAX; + *ret = UINT64_MAX; return 0; } - *timeout_usec = c->timeout; + *ret = c->timeout; return 1; } diff --git a/src/libsystemd/sd-netlink/test-netlink.c b/src/libsystemd/sd-netlink/test-netlink.c index c58cfc0727..d51b7cf76b 100644 --- a/src/libsystemd/sd-netlink/test-netlink.c +++ b/src/libsystemd/sd-netlink/test-netlink.c @@ -108,7 +108,7 @@ TEST(message_address) { assert_se(sd_netlink_message_read_in_addr(reply, IFA_LOCAL, &in_data) >= 0); assert_se(sd_netlink_message_read_in_addr(reply, IFA_ADDRESS, &in_data) >= 0); assert_se(sd_netlink_message_read_string(reply, IFA_LABEL, &label) >= 0); - assert_se(sd_netlink_message_read_cache_info(reply, IFA_CACHEINFO, &cache) == 0); + assert_se(sd_netlink_message_read_cache_info(reply, IFA_CACHEINFO, &cache) >= 0); } } diff --git a/src/network/networkd-json.c b/src/network/networkd-json.c index dd2120b5e1..d1a7bd586c 100644 --- a/src/network/networkd-json.c +++ b/src/network/networkd-json.c @@ -307,8 +307,8 @@ static int routing_policy_rule_append_json(RoutingPolicyRule *rule, sd_json_vari SD_JSON_BUILD_PAIR_UNSIGNED("Protocol", rule->protocol), SD_JSON_BUILD_PAIR_STRING("ProtocolString", protocol), SD_JSON_BUILD_PAIR_UNSIGNED("TOS", rule->tos), - SD_JSON_BUILD_PAIR_UNSIGNED("Type", rule->type), - SD_JSON_BUILD_PAIR_STRING("TypeString", fr_act_type_to_string(rule->type)), + SD_JSON_BUILD_PAIR_UNSIGNED("Type", rule->action), + SD_JSON_BUILD_PAIR_STRING("TypeString", fr_act_type_to_string(rule->action)), SD_JSON_BUILD_PAIR_UNSIGNED("IPProtocol", rule->ipproto), SD_JSON_BUILD_PAIR_STRING("IPProtocolString", ip_protocol_to_name(rule->ipproto)), SD_JSON_BUILD_PAIR_UNSIGNED("Priority", rule->priority), diff --git a/src/network/networkd-network-gperf.gperf b/src/network/networkd-network-gperf.gperf index 729cb5c066..1f9e6eafc0 100644 --- a/src/network/networkd-network-gperf.gperf +++ b/src/network/networkd-network-gperf.gperf @@ -194,7 +194,7 @@ RoutingPolicyRule.Family, config_parse_routing_policy_rule, RoutingPolicyRule.User, config_parse_routing_policy_rule, ROUTING_POLICY_RULE_UID_RANGE, 0 RoutingPolicyRule.SuppressInterfaceGroup, config_parse_routing_policy_rule, ROUTING_POLICY_RULE_SUPPRESS_IFGROUP, 0 RoutingPolicyRule.SuppressPrefixLength, config_parse_routing_policy_rule, ROUTING_POLICY_RULE_SUPPRESS_PREFIXLEN, 0 -RoutingPolicyRule.Type, config_parse_routing_policy_rule, ROUTING_POLICY_RULE_TYPE, 0 +RoutingPolicyRule.Type, config_parse_routing_policy_rule, ROUTING_POLICY_RULE_ACTION, 0 Route.Gateway, config_parse_gateway, 0, 0 Route.Destination, config_parse_destination, 0, 0 Route.Source, config_parse_destination, 0, 0 diff --git a/src/network/networkd-nexthop.h b/src/network/networkd-nexthop.h index b304125a04..b918bc6ea3 100644 --- a/src/network/networkd-nexthop.h +++ b/src/network/networkd-nexthop.h @@ -29,7 +29,7 @@ typedef struct NextHop { /* struct nhmsg */ int family; uint8_t protocol; - uint8_t flags; + uint32_t flags; /* attributes */ uint32_t id; /* NHA_ID */ diff --git a/src/network/networkd-routing-policy-rule.c b/src/network/networkd-routing-policy-rule.c index 6fba52e887..c03493b7e0 100644 --- a/src/network/networkd-routing-policy-rule.c +++ b/src/network/networkd-routing-policy-rule.c @@ -111,7 +111,7 @@ static int routing_policy_rule_new(RoutingPolicyRule **ret) { .suppress_prefixlen = -1, .suppress_ifgroup = -1, .protocol = RTPROT_UNSPEC, - .type = FR_ACT_TO_TBL, + .action = FR_ACT_TO_TBL, }; *ret = rule; @@ -196,7 +196,7 @@ static void routing_policy_rule_hash_func(const RoutingPolicyRule *rule, struct /* See rule_exists() in net/core/fib_rules.c of the kernel. */ siphash24_compress_typesafe(rule->family, state); - siphash24_compress_typesafe(rule->type, state); + siphash24_compress_typesafe(rule->action, state); siphash24_compress_typesafe(rule->table, state); siphash24_compress_typesafe(rule->priority, state); siphash24_compress_string(rule->iif, state); @@ -235,7 +235,7 @@ static int routing_policy_rule_compare_func_full(const RoutingPolicyRule *a, con return r; } - r = CMP(a->type, b->type); + r = CMP(a->action, b->action); if (r != 0) return r; @@ -365,7 +365,7 @@ static bool routing_policy_rule_can_update(const RoutingPolicyRule *existing, co return false; /* GOTO target cannot be updated. */ - if (existing->type == FR_ACT_GOTO && existing->priority_goto != requesting->priority_goto) + if (existing->action == FR_ACT_GOTO && existing->priority_goto != requesting->priority_goto) return false; return true; @@ -515,7 +515,7 @@ static int routing_policy_rule_acquire_priority(Manager *manager, RoutingPolicyR } /* priority must be smaller than goto target */ - for (priority = rule->type == FR_ACT_GOTO ? rule->priority_goto - 1 : 32765; priority > 0; priority--) + for (priority = rule->action == FR_ACT_GOTO ? rule->priority_goto - 1 : 32765; priority > 0; priority--) if (!set_contains(priorities, UINT32_TO_PTR(priority))) break; @@ -560,7 +560,7 @@ static int routing_policy_rule_set_netlink_message(const RoutingPolicyRule *rule if (r < 0) return r; - r = sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(m, rule->from_prefixlen); + r = sd_rtnl_message_routing_policy_rule_set_src_prefixlen(m, rule->from_prefixlen); if (r < 0) return r; } @@ -570,7 +570,7 @@ static int routing_policy_rule_set_netlink_message(const RoutingPolicyRule *rule if (r < 0) return r; - r = sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(m, rule->to_prefixlen); + r = sd_rtnl_message_routing_policy_rule_set_dst_prefixlen(m, rule->to_prefixlen); if (r < 0) return r; } @@ -667,11 +667,11 @@ static int routing_policy_rule_set_netlink_message(const RoutingPolicyRule *rule return r; } - r = sd_rtnl_message_routing_policy_rule_set_fib_type(m, rule->type); + r = sd_rtnl_message_routing_policy_rule_set_action(m, rule->action); if (r < 0) return r; - if (rule->type == FR_ACT_GOTO) { + if (rule->action == FR_ACT_GOTO) { r = sd_netlink_message_append_u32(m, FRA_GOTO, rule->priority_goto); if (r < 0) return r; @@ -1039,13 +1039,13 @@ int link_request_static_routing_policy_rules(Link *link) { } static const RoutingPolicyRule kernel_rules[] = { - { .family = AF_INET, .priority_set = true, .priority = 0, .table = RT_TABLE_LOCAL, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, - { .family = AF_INET, .priority_set = true, .priority = 1000, .table = RT_TABLE_UNSPEC, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, .l3mdev = true }, - { .family = AF_INET, .priority_set = true, .priority = 32766, .table = RT_TABLE_MAIN, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, - { .family = AF_INET, .priority_set = true, .priority = 32767, .table = RT_TABLE_DEFAULT, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, - { .family = AF_INET6, .priority_set = true, .priority = 0, .table = RT_TABLE_LOCAL, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, - { .family = AF_INET6, .priority_set = true, .priority = 1000, .table = RT_TABLE_UNSPEC, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, .l3mdev = true }, - { .family = AF_INET6, .priority_set = true, .priority = 32766, .table = RT_TABLE_MAIN, .type = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, + { .family = AF_INET, .priority_set = true, .priority = 0, .table = RT_TABLE_LOCAL, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, + { .family = AF_INET, .priority_set = true, .priority = 1000, .table = RT_TABLE_UNSPEC, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, .l3mdev = true }, + { .family = AF_INET, .priority_set = true, .priority = 32766, .table = RT_TABLE_MAIN, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, + { .family = AF_INET, .priority_set = true, .priority = 32767, .table = RT_TABLE_DEFAULT, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, + { .family = AF_INET6, .priority_set = true, .priority = 0, .table = RT_TABLE_LOCAL, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, + { .family = AF_INET6, .priority_set = true, .priority = 1000, .table = RT_TABLE_UNSPEC, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, .l3mdev = true }, + { .family = AF_INET6, .priority_set = true, .priority = 32766, .table = RT_TABLE_MAIN, .action = FR_ACT_TO_TBL, .uid_range.start = UID_INVALID, .uid_range.end = UID_INVALID, .suppress_prefixlen = -1, .suppress_ifgroup = -1, }, }; static bool routing_policy_rule_is_created_by_kernel(const RoutingPolicyRule *rule) { @@ -1105,7 +1105,7 @@ int manager_rtnl_process_rule(sd_netlink *rtnl, sd_netlink_message *message, Man log_warning_errno(r, "rtnl: could not get FRA_SRC attribute, ignoring: %m"); return 0; } else if (r >= 0) { - r = sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(message, &tmp->from_prefixlen); + r = sd_rtnl_message_routing_policy_rule_get_src_prefixlen(message, &tmp->from_prefixlen); if (r < 0) { log_warning_errno(r, "rtnl: received rule message without valid source prefix length, ignoring: %m"); return 0; @@ -1117,7 +1117,7 @@ int manager_rtnl_process_rule(sd_netlink *rtnl, sd_netlink_message *message, Man log_warning_errno(r, "rtnl: could not get FRA_DST attribute, ignoring: %m"); return 0; } else if (r >= 0) { - r = sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(message, &tmp->to_prefixlen); + r = sd_rtnl_message_routing_policy_rule_get_dst_prefixlen(message, &tmp->to_prefixlen); if (r < 0) { log_warning_errno(r, "rtnl: received rule message without valid destination prefix length, ignoring: %m"); return 0; @@ -1157,9 +1157,9 @@ int manager_rtnl_process_rule(sd_netlink *rtnl, sd_netlink_message *message, Man return 0; } - r = sd_rtnl_message_routing_policy_rule_get_fib_type(message, &tmp->type); + r = sd_rtnl_message_routing_policy_rule_get_action(message, &tmp->action); if (r < 0 && r != -ENODATA) { - log_warning_errno(r, "rtnl: could not get FIB rule type, ignoring: %m"); + log_warning_errno(r, "rtnl: could not get FIB rule action, ignoring: %m"); return 0; } @@ -1409,7 +1409,7 @@ static int config_parse_routing_policy_rule_goto( return 0; } - rule->type = FR_ACT_GOTO; + rule->action = FR_ACT_GOTO; rule->priority_goto = priority; return 1; } @@ -1605,7 +1605,7 @@ static int config_parse_routing_policy_rule_suppress( return 1; } -static int config_parse_routing_policy_rule_type( +static int config_parse_routing_policy_rule_action( const char *unit, const char *filename, unsigned line, @@ -1625,7 +1625,7 @@ static int config_parse_routing_policy_rule_type( r = fr_act_type_from_string(rvalue); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, - "Could not parse FIB rule type \"%s\", ignoring assignment: %m", rvalue); + "Could not parse FIB rule action \"%s\", ignoring assignment: %m", rvalue); return 0; } @@ -1668,7 +1668,7 @@ int config_parse_routing_policy_rule( [ROUTING_POLICY_RULE_SUPPRESS_PREFIXLEN] = { .parser = config_parse_routing_policy_rule_suppress, .ltype = 128, .offset = offsetof(RoutingPolicyRule, suppress_prefixlen), }, [ROUTING_POLICY_RULE_TABLE] = { .parser = config_parse_routing_policy_rule_table, .ltype = 0, .offset = offsetof(RoutingPolicyRule, table), }, [ROUTING_POLICY_RULE_TOS] = { .parser = config_parse_uint8, .ltype = 0, .offset = offsetof(RoutingPolicyRule, tos), }, - [ROUTING_POLICY_RULE_TYPE] = { .parser = config_parse_routing_policy_rule_type, .ltype = 0, .offset = offsetof(RoutingPolicyRule, type), }, + [ROUTING_POLICY_RULE_ACTION] = { .parser = config_parse_routing_policy_rule_action, .ltype = 0, .offset = offsetof(RoutingPolicyRule, action), }, [ROUTING_POLICY_RULE_UID_RANGE] = { .parser = config_parse_routing_policy_rule_uid_range, .ltype = 0, .offset = offsetof(RoutingPolicyRule, uid_range), }, }; @@ -1724,7 +1724,7 @@ static int routing_policy_rule_section_verify(RoutingPolicyRule *rule) { if (rule->l3mdev) rule->table = RT_TABLE_UNSPEC; - if (rule->type == FR_ACT_GOTO) { + if (rule->action == FR_ACT_GOTO) { if (rule->priority_goto <= 0) return log_rule_section(rule, "Type=goto is specified but the target priority GoTo= is unspecified."); diff --git a/src/network/networkd-routing-policy-rule.h b/src/network/networkd-routing-policy-rule.h index b57a16ee7c..443df39dd2 100644 --- a/src/network/networkd-routing-policy-rule.h +++ b/src/network/networkd-routing-policy-rule.h @@ -28,7 +28,7 @@ typedef struct RoutingPolicyRule { uint8_t to_prefixlen; uint8_t from_prefixlen; uint8_t tos; - uint8_t type; /* a.k.a action */ + uint8_t action; uint32_t flags; /* attributes */ @@ -94,7 +94,7 @@ typedef enum RoutingPolicyRuleConfParserType { ROUTING_POLICY_RULE_SUPPRESS_PREFIXLEN, ROUTING_POLICY_RULE_TABLE, ROUTING_POLICY_RULE_TOS, - ROUTING_POLICY_RULE_TYPE, + ROUTING_POLICY_RULE_ACTION, ROUTING_POLICY_RULE_UID_RANGE, _ROUTING_POLICY_RULE_CONF_PARSER_MAX, _ROUTING_POLICY_RULE_CONF_PARSER_INVALID = -EINVAL, diff --git a/src/systemd/sd-netlink.h b/src/systemd/sd-netlink.h index e4f5e32c57..aeb08ef97f 100644 --- a/src/systemd/sd-netlink.h +++ b/src/systemd/sd-netlink.h @@ -44,19 +44,18 @@ int sd_netlink_open(sd_netlink **ret); int sd_netlink_open_fd(sd_netlink **ret, int fd); int sd_netlink_increase_rxbuf(sd_netlink *nl, const size_t size); -sd_netlink *sd_netlink_ref(sd_netlink *nl); -sd_netlink *sd_netlink_unref(sd_netlink *nl); +sd_netlink* sd_netlink_ref(sd_netlink *nl); +sd_netlink* sd_netlink_unref(sd_netlink *nl); -int sd_netlink_send(sd_netlink *nl, sd_netlink_message *message, uint32_t *serial); +int sd_netlink_send(sd_netlink *nl, sd_netlink_message *message, uint32_t *ret_serial); int sd_netlink_call_async(sd_netlink *nl, sd_netlink_slot **ret_slot, sd_netlink_message *message, sd_netlink_message_handler_t callback, sd_netlink_destroy_t destroy_callback, void *userdata, uint64_t usec, const char *description); -int sd_netlink_call(sd_netlink *nl, sd_netlink_message *message, uint64_t timeout, - sd_netlink_message **reply); -int sd_netlink_read(sd_netlink *nl, uint32_t serial, uint64_t timeout, sd_netlink_message **reply); +int sd_netlink_call(sd_netlink *nl, sd_netlink_message *message, uint64_t timeout, sd_netlink_message **ret); +int sd_netlink_read(sd_netlink *nl, uint32_t serial, uint64_t timeout, sd_netlink_message **ret); int sd_netlink_get_events(sd_netlink *nl); -int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout); +int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *ret); int sd_netlink_process(sd_netlink *nl, sd_netlink_message **ret); int sd_netlink_wait(sd_netlink *nl, uint64_t timeout); @@ -104,19 +103,19 @@ int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type); int sd_netlink_message_cancel_array(sd_netlink_message *m); /* Reading messages */ -int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *data); +int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *ret); int sd_netlink_message_read_data(sd_netlink_message *m, uint16_t attr_type, size_t *ret_size, void **ret_data); -int sd_netlink_message_read_string_strdup(sd_netlink_message *m, uint16_t attr_type, char **data); -int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, const char **data); +int sd_netlink_message_read_string_strdup(sd_netlink_message *m, uint16_t attr_type, char **ret); +int sd_netlink_message_read_string(sd_netlink_message *m, uint16_t attr_type, const char **ret); int sd_netlink_message_read_strv(sd_netlink_message *m, uint16_t container_type, uint16_t attr_type, char ***ret); -int sd_netlink_message_read_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t *data); -int sd_netlink_message_read_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t *data); -int sd_netlink_message_read_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t *data); +int sd_netlink_message_read_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t *ret); +int sd_netlink_message_read_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t *ret); +int sd_netlink_message_read_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t *ret); int sd_netlink_message_read_u64(sd_netlink_message *m, uint16_t attr_type, uint64_t *ret); -int sd_netlink_message_read_ether_addr(sd_netlink_message *m, uint16_t attr_type, struct ether_addr *data); -int sd_netlink_message_read_cache_info(sd_netlink_message *m, uint16_t attr_type, struct ifa_cacheinfo *info); -int sd_netlink_message_read_in_addr(sd_netlink_message *m, uint16_t attr_type, struct in_addr *data); -int sd_netlink_message_read_in6_addr(sd_netlink_message *m, uint16_t attr_type, struct in6_addr *data); +int sd_netlink_message_read_ether_addr(sd_netlink_message *m, uint16_t attr_type, struct ether_addr *ret); +int sd_netlink_message_read_cache_info(sd_netlink_message *m, uint16_t attr_type, struct ifa_cacheinfo *ret); +int sd_netlink_message_read_in_addr(sd_netlink_message *m, uint16_t attr_type, struct in_addr *ret); +int sd_netlink_message_read_in6_addr(sd_netlink_message *m, uint16_t attr_type, struct in6_addr *ret); int sd_netlink_message_has_flag(sd_netlink_message *m, uint16_t attr_type); int sd_netlink_message_enter_container(sd_netlink_message *m, uint16_t attr_type); int sd_netlink_message_enter_array(sd_netlink_message *m, uint16_t attr_type); @@ -124,98 +123,108 @@ int sd_netlink_message_exit_container(sd_netlink_message *m); int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl); -sd_netlink_message *sd_netlink_message_next(sd_netlink_message *m); +sd_netlink_message* sd_netlink_message_next(sd_netlink_message *m); -sd_netlink_message *sd_netlink_message_ref(sd_netlink_message *m); -sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m); +sd_netlink_message* sd_netlink_message_ref(sd_netlink_message *m); +sd_netlink_message* sd_netlink_message_unref(sd_netlink_message *m); int sd_netlink_message_set_request_dump(sd_netlink_message *m, int dump); int sd_netlink_message_is_error(sd_netlink_message *m); int sd_netlink_message_get_errno(sd_netlink_message *m); -int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type); +int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *ret); int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags); int sd_netlink_message_is_broadcast(sd_netlink_message *m); int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret); /* rtnl */ -int sd_rtnl_message_get_family(sd_netlink_message *m, int *family); +int sd_rtnl_message_get_family(sd_netlink_message *m, int *ret); -int sd_rtnl_message_new_addr(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index, int family); -int sd_rtnl_message_new_addr_update(sd_netlink *nl, sd_netlink_message **ret, int index, 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); -int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags); -int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family); -int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *ret_prefixlen); -int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *ret_scope); -int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *ret_flags); -int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ret_ifindex); +int sd_rtnl_message_new_addr(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int ifindex, int family); +int sd_rtnl_message_new_addr_update(sd_netlink *nl, sd_netlink_message **ret, int ifindex, int family); +/* struct ifaddrmsg */ +int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ret); /* ifa_index */ +int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *ret); /* ifa_family */ +int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* ifa_prefixlen */ +int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, uint8_t flags); /* ifa_flags */ +int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, uint8_t scope); /* ifa_scope */ +int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, uint8_t *ret); -int sd_rtnl_message_new_link(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index); -int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change); -int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type); -int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family); -int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex); -int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags); -int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type); +int sd_rtnl_message_new_link(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int ifindex); +/* struct ifinfomsg */ +int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ret); /* ifi_index */ +int sd_rtnl_message_link_set_family(sd_netlink_message *m, int family); /* ifi_family */ +int sd_rtnl_message_link_get_family(sd_netlink_message *m, int *ret); +int sd_rtnl_message_link_set_type(sd_netlink_message *m, uint16_t type); /* ifi_type */ +int sd_rtnl_message_link_get_type(sd_netlink_message *m, uint16_t *ret); +int sd_rtnl_message_link_set_flags(sd_netlink_message *m, uint32_t flags, uint32_t change); /* ifi_flags and ifi_change */ +int sd_rtnl_message_link_get_flags(sd_netlink_message *m, uint32_t *ret); /* ifi_flags */ -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_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen); -int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen); -int sd_rtnl_message_route_set_tos(sd_netlink_message *m, unsigned char tos); -int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope); -int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags); -int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table); -int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type); -int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags); -int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family); -int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol); -int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope); -int sd_rtnl_message_route_get_tos(sd_netlink_message *m, unsigned char *tos); -int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table); -int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len); -int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len); -int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type); +int sd_rtnl_message_new_route(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, int family, uint8_t protocol); +/* struct rtmsg */ +int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *ret); /* rtm_family */ +int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* rtm_dst_len */ +int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* rtm_src_len */ +int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_set_tos(sd_netlink_message *m, uint8_t tos); /* rtm_tos */ +int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_set_table(sd_netlink_message *m, uint8_t table); /* rtm_table */ +int sd_rtnl_message_route_get_table(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, uint8_t *ret); /* rtm_protocol */ +int sd_rtnl_message_route_set_scope(sd_netlink_message *m, uint8_t scope); /* rtm_scope */ +int sd_rtnl_message_route_get_scope(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_set_type(sd_netlink_message *m, uint8_t type); /* rtm_type */ +int sd_rtnl_message_route_get_type(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_route_set_flags(sd_netlink_message *m, uint32_t flags); /* rtm_flags */ +int sd_rtnl_message_route_get_flags(sd_netlink_message *m, uint32_t *ret); -int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int nh_family, unsigned char nh_protocol); -int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags); -int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret); -int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family); -int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol); +int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int family, uint8_t protocol); +/* struct nhmsg */ +int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, int *ret); /* nh_family */ +int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint32_t flags); /* nh_flags, RTNH_F flags */ +int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint32_t *ret); +int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *ret); /* nh_protocol */ -int sd_rtnl_message_new_neigh(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int nda_family); -int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags); -int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state); -int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family); -int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index); -int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state); -int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags); +int sd_rtnl_message_new_neigh(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, int family); +/* struct ndmsg */ +int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *ret); /* ndm_ifindex */ +int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *ret); /* ndm_family */ +int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state); /* ndm_state */ +int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *ret); +int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags); /* ndm_flags */ +int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *ret); -int sd_rtnl_message_new_addrlabel(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, int ifal_family); -int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen); -int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen); +int sd_rtnl_message_new_addrlabel(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, int family); +/* struct ifaddrlblmsg */ +int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* ifal_prefixlen */ +int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, uint8_t *ret); -int sd_rtnl_message_new_routing_policy_rule(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifal_family); -int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos); -int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *tos); -int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table); -int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *table); -int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message *m, uint8_t len); -int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message *m, uint8_t *len); -int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message *m, uint8_t len); -int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message *m, uint8_t *len); -int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint8_t type); -int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint8_t *type); -int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags); -int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *flags); +int sd_rtnl_message_new_routing_policy_rule(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int family); +/* struct fib_rule_hdr */ +int sd_rtnl_message_routing_policy_rule_get_family(sd_netlink_message *m, int *ret); /* family */ +int sd_rtnl_message_routing_policy_rule_set_dst_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* dst_len */ +int sd_rtnl_message_routing_policy_rule_get_dst_prefixlen(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_routing_policy_rule_set_src_prefixlen(sd_netlink_message *m, uint8_t prefixlen); /* src_len*/ +int sd_rtnl_message_routing_policy_rule_get_src_prefixlen(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos); /* tos */ +int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table); /* table */ +int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_routing_policy_rule_set_action(sd_netlink_message *m, uint8_t action); /* action */ +int sd_rtnl_message_routing_policy_rule_get_action(sd_netlink_message *m, uint8_t *ret); +int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags); /* flags */ +int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *ret); int sd_rtnl_message_new_traffic_control(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, uint32_t handle, uint32_t parent); -int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret); -int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret); -int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret); +/* struct tcmsg */ +int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret); /* tcm_ifindex */ +int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret); /* tcm_handle */ +int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret); /* tcm_parent */ -int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int mdb_ifindex); +int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex); int sd_rtnl_message_new_nsid(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type); @@ -234,14 +243,14 @@ int sd_genl_add_match(sd_netlink *nl, sd_netlink_slot **ret_slot, const char *fa sd_netlink_slot *sd_netlink_slot_ref(sd_netlink_slot *slot); sd_netlink_slot *sd_netlink_slot_unref(sd_netlink_slot *slot); -sd_netlink *sd_netlink_slot_get_netlink(sd_netlink_slot *slot); -void *sd_netlink_slot_get_userdata(sd_netlink_slot *slot); -void *sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata); -int sd_netlink_slot_get_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t *callback); +sd_netlink* sd_netlink_slot_get_netlink(sd_netlink_slot *slot); +void* sd_netlink_slot_get_userdata(sd_netlink_slot *slot); +void* sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata); +int sd_netlink_slot_get_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t *ret); int sd_netlink_slot_set_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t callback); int sd_netlink_slot_get_floating(sd_netlink_slot *slot); int sd_netlink_slot_set_floating(sd_netlink_slot *slot, int b); -int sd_netlink_slot_get_description(sd_netlink_slot *slot, const char **description); +int sd_netlink_slot_get_description(sd_netlink_slot *slot, const char **ret); int sd_netlink_slot_set_description(sd_netlink_slot *slot, const char *description); _SD_DEFINE_POINTER_CLEANUP_FUNC(sd_netlink, sd_netlink_unref);