LIBSYSTEMD_252 {
global:
sd_hwdb_new_from_path;
+
+ sd_netlink_new_from_fd;
+ sd_netlink_open;
+ sd_netlink_open_fd;
+ sd_netlink_inc_rcvbuf;
+ sd_netlink_ref;
+ sd_netlink_unref;
+ sd_netlink_send;
+ sd_netlink_call_async;
+ sd_netlink_call;
+ sd_netlink_read;
+ sd_netlink_get_events;
+ sd_netlink_get_timeout;
+ sd_netlink_process;
+ sd_netlink_wait;
+ sd_netlink_add_match;
+ sd_netlink_attach_event;
+ sd_netlink_detach_event;
+ sd_netlink_attach_filter;
+ sd_netlink_message_append_string;
+ sd_netlink_message_append_strv;
+ sd_netlink_message_append_flag;
+ sd_netlink_message_append_u8;
+ sd_netlink_message_append_u16;
+ sd_netlink_message_append_u32;
+ sd_netlink_message_append_u64;
+ sd_netlink_message_append_s8;
+ sd_netlink_message_append_s16;
+ sd_netlink_message_append_s32;
+ sd_netlink_message_append_s64;
+ sd_netlink_message_append_data;
+ sd_netlink_message_append_in_addr;
+ sd_netlink_message_append_in6_addr;
+ sd_netlink_message_append_sockaddr_in;
+ sd_netlink_message_append_sockaddr_in6;
+ sd_netlink_message_append_ether_addr;
+ sd_netlink_message_append_cache_info;
+ sd_netlink_message_open_container;
+ sd_netlink_message_open_container_union;
+ sd_netlink_message_close_container;
+ sd_netlink_message_read;
+ sd_netlink_message_read_data;
+ sd_netlink_message_read_data_suffix0;
+ sd_netlink_message_read_string_strdup;
+ sd_netlink_message_read_string;
+ sd_netlink_message_read_strv;
+ sd_netlink_message_read_u8;
+ sd_netlink_message_read_u16;
+ sd_netlink_message_read_u32;
+ sd_netlink_message_read_ether_addr;
+ sd_netlink_message_read_cache_info;
+ sd_netlink_message_read_in_addr;
+ sd_netlink_message_read_in6_addr;
+ sd_netlink_message_has_flag;
+ sd_netlink_message_enter_container;
+ sd_netlink_message_enter_array;
+ sd_netlink_message_exit_container;
+ sd_netlink_message_open_array;
+ sd_netlink_message_cancel_array;
+ sd_netlink_message_rewind;
+ sd_netlink_message_next;
+ sd_netlink_message_ref;
+ sd_netlink_message_unref;
+ sd_netlink_message_request_dump;
+ sd_netlink_message_is_error;
+ sd_netlink_message_get_errno;
+ sd_netlink_message_get_type;
+ sd_netlink_message_set_flags;
+ sd_netlink_message_is_broadcast;
+ sd_netlink_message_get_max_attribute;
+ sd_netlink_slot_ref;
+ sd_netlink_slot_unref;
+ sd_netlink_slot_get_netlink;
+ sd_netlink_slot_get_userdata;
+ sd_netlink_slot_set_userdata;
+ sd_netlink_slot_get_destroy_callback;
+ sd_netlink_slot_set_destroy_callback;
+ sd_netlink_slot_get_floating;
+ sd_netlink_slot_set_floating;
+ sd_netlink_slot_get_description;
+ sd_netlink_slot_set_description;
+
+ sd_rtnl_message_get_family;
+ sd_rtnl_message_new_addr;
+ sd_rtnl_message_new_addr_update;
+ sd_rtnl_message_addr_set_prefixlen;
+ sd_rtnl_message_addr_set_scope;
+ sd_rtnl_message_addr_set_flags;
+ sd_rtnl_message_addr_get_family;
+ sd_rtnl_message_addr_get_prefixlen;
+ sd_rtnl_message_addr_get_scope;
+ sd_rtnl_message_addr_get_flags;
+ sd_rtnl_message_addr_get_ifindex;
+ sd_rtnl_message_new_link;
+ sd_rtnl_message_link_set_flags;
+ sd_rtnl_message_link_set_type;
+ sd_rtnl_message_link_set_family;
+ sd_rtnl_message_link_get_ifindex;
+ sd_rtnl_message_link_get_flags;
+ sd_rtnl_message_link_get_type;
+ sd_rtnl_message_new_route;
+ sd_rtnl_message_route_set_dst_prefixlen;
+ sd_rtnl_message_route_set_src_prefixlen;
+ sd_rtnl_message_route_set_scope;
+ sd_rtnl_message_route_set_flags;
+ sd_rtnl_message_route_set_table;
+ sd_rtnl_message_route_set_type;
+ sd_rtnl_message_route_get_flags;
+ sd_rtnl_message_route_get_family;
+ sd_rtnl_message_route_get_protocol;
+ sd_rtnl_message_route_get_scope;
+ sd_rtnl_message_route_get_tos;
+ sd_rtnl_message_route_get_table;
+ sd_rtnl_message_route_get_dst_prefixlen;
+ sd_rtnl_message_route_get_src_prefixlen;
+ sd_rtnl_message_route_get_type;
+ sd_rtnl_message_new_nexthop;
+ sd_rtnl_message_nexthop_set_flags;
+ sd_rtnl_message_nexthop_get_flags;
+ sd_rtnl_message_nexthop_get_family;
+ sd_rtnl_message_nexthop_get_protocol;
+ sd_rtnl_message_new_neigh;
+ sd_rtnl_message_neigh_set_flags;
+ sd_rtnl_message_neigh_set_state;
+ sd_rtnl_message_neigh_get_family;
+ sd_rtnl_message_neigh_get_ifindex;
+ sd_rtnl_message_neigh_get_state;
+ sd_rtnl_message_neigh_get_flags;
+ sd_rtnl_message_new_addrlabel;
+ sd_rtnl_message_addrlabel_set_prefixlen;
+ sd_rtnl_message_addrlabel_get_prefixlen;
+ sd_rtnl_message_new_routing_policy_rule;
+ sd_rtnl_message_routing_policy_rule_set_tos;
+ sd_rtnl_message_routing_policy_rule_get_tos;
+ sd_rtnl_message_routing_policy_rule_set_table;
+ sd_rtnl_message_routing_policy_rule_get_table;
+ sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen;
+ sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen;
+ sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen;
+ sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen;
+ sd_rtnl_message_routing_policy_rule_set_fib_type;
+ sd_rtnl_message_routing_policy_rule_get_fib_type;
+ sd_rtnl_message_routing_policy_rule_set_flags;
+ sd_rtnl_message_routing_policy_rule_get_flags;
+ sd_rtnl_message_new_traffic_control;
+ sd_rtnl_message_traffic_control_get_ifindex;
+ sd_rtnl_message_traffic_control_get_handle;
+ sd_rtnl_message_traffic_control_get_parent;
+ sd_rtnl_message_new_mdb;
+
+ sd_genl_socket_open;
+ sd_genl_message_new;
+ sd_genl_message_get_family_name;
+ sd_genl_message_get_command;
+ sd_genl_add_match;
} LIBSYSTEMD_251;
return 0;
}
-int sd_genl_message_new(sd_netlink *nl, const char *family_name, uint8_t cmd, sd_netlink_message **ret) {
+_public_ int sd_genl_message_new(sd_netlink *nl, const char *family_name, uint8_t cmd, sd_netlink_message **ret) {
const GenericNetlinkFamily *family;
int r;
return genl_message_new(nl, family, cmd, ret);
}
-int sd_genl_message_get_family_name(sd_netlink *nl, sd_netlink_message *m, const char **ret) {
+_public_ int sd_genl_message_get_family_name(sd_netlink *nl, sd_netlink_message *m, const char **ret) {
const GenericNetlinkFamily *family;
uint16_t nlmsg_type;
int r;
return 0;
}
-int sd_genl_message_get_command(sd_netlink *nl, sd_netlink_message *m, uint8_t *ret) {
+_public_ int sd_genl_message_get_command(sd_netlink *nl, sd_netlink_message *m, uint8_t *ret) {
struct genlmsghdr *h;
uint16_t nlmsg_type;
size_t size;
return 0;
}
-int sd_genl_add_match(
+_public_ int sd_genl_add_match(
sd_netlink *nl,
sd_netlink_slot **ret_slot,
const char *family_name,
callback, destroy_callback, userdata, description);
}
-int sd_genl_socket_open(sd_netlink **ret) {
+_public_ int sd_genl_socket_open(sd_netlink **ret) {
return netlink_open_family(ret, NETLINK_GENERIC);
}
sd_netlink_message **ret);
int message_new(sd_netlink *nl, sd_netlink_message **ret, uint16_t type);
int message_new_synthetic_error(sd_netlink *nl, int error, uint32_t serial, sd_netlink_message **ret);
-uint32_t message_get_serial(sd_netlink_message *m);
+
+static inline uint32_t message_get_serial(sd_netlink_message *m) {
+ assert(m);
+ return ASSERT_PTR(m->hdr)->nlmsg_seq;
+}
+
void message_seal(sd_netlink_message *m);
int netlink_open_family(sd_netlink **ret, int family);
int netlink_rqueue_make_room(sd_netlink *nl);
int netlink_rqueue_partial_make_room(sd_netlink *nl);
-int socket_open(int family);
int socket_bind(sd_netlink *nl);
int socket_broadcast_group_ref(sd_netlink *nl, unsigned group);
int socket_broadcast_group_unref(sd_netlink *nl, unsigned group);
int socket_write_message(sd_netlink *nl, sd_netlink_message *m);
-int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount);
int socket_read_message(sd_netlink *nl);
int netlink_add_match_internal(
/* Make sure callbacks don't destroy the netlink connection */
#define NETLINK_DONT_DESTROY(nl) \
_cleanup_(sd_netlink_unrefp) _unused_ sd_netlink *_dont_destroy_##nl = sd_netlink_ref(nl)
+
+/* nfnl */
+/* TODO: to be exported later */
+int sd_nfnl_socket_open(sd_netlink **ret);
+int sd_nfnl_message_batch_begin(sd_netlink *nfnl, sd_netlink_message **ret);
+int sd_nfnl_message_batch_end(sd_netlink *nfnl, sd_netlink_message **ret);
+int sd_nfnl_nft_message_del_table(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table);
+int sd_nfnl_nft_message_new_table(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table);
+int sd_nfnl_nft_message_new_basechain(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table, const char *chain,
+ const char *type, uint8_t hook, int prio);
+int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table, const char *chain);
+int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table, const char *set_name,
+ uint32_t setid, uint32_t klen);
+int sd_nfnl_nft_message_new_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table, const char *set_name);
+int sd_nfnl_nft_message_del_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret,
+ int family, const char *table, const char *set_name);
+int sd_nfnl_nft_message_add_setelem(sd_netlink_message *m,
+ uint32_t num,
+ const void *key, uint32_t klen,
+ const void *data, uint32_t dlen);
+int sd_nfnl_nft_message_add_setelem_end(sd_netlink_message *m);
#include "socket-util.h"
#include "util.h"
-int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
+_public_ int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
+_public_ int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) {
+_public_ int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags) {
+_public_ int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) {
+_public_ int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) {
+_public_ int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) {
+_public_ int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type) {
+_public_ int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) {
+_public_ int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol) {
+_public_ int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope) {
+_public_ int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) {
+_public_ int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) {
+_public_ int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) {
+_public_ int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) {
+_public_ int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret,
+_public_ 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;
return 0;
}
-int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret,
+_public_ 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;
return 0;
}
-int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) {
+_public_ int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) {
struct nhmsg *nhm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) {
+_public_ int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) {
struct nhmsg *nhm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) {
+_public_ int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) {
struct nhmsg *nhm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol) {
+_public_ int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol) {
struct nhmsg *nhm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) {
+_public_ int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) {
+_public_ int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) {
+_public_ int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) {
+_public_ int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) {
+_public_ int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) {
+_public_ int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
+_public_ 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;
return 0;
}
-int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) {
+_public_ int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) {
+_public_ int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) {
+_public_ int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret,
+_public_ int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index) {
struct ifinfomsg *ifi;
int r;
return 0;
}
-int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
+_public_ int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) {
+_public_ int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) {
+_public_ int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) {
+_public_ int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
+_public_ int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) {
+_public_ int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) {
+_public_ int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) {
+_public_ int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret,
- uint16_t nlmsg_type, int index,
- int family) {
+_public_ int sd_rtnl_message_new_addr(
+ sd_netlink *rtnl,
+ sd_netlink_message **ret,
+ uint16_t nlmsg_type,
+ int index,
+ int family) {
+
struct ifaddrmsg *ifa;
int r;
return 0;
}
-int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret,
- int index, int family) {
+_public_ int sd_rtnl_message_new_addr_update(
+ sd_netlink *rtnl,
+ sd_netlink_message **ret,
+ int index,
+ int family) {
int r;
r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family);
return 0;
}
-int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) {
+_public_ int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) {
+_public_ int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type) {
+_public_ int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) {
+_public_ int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) {
assert_return(m, -EINVAL);
assert_return(family, -EINVAL);
return -EOPNOTSUPP;
}
-int sd_rtnl_message_new_addrlabel(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, int ifal_family) {
+_public_ int sd_rtnl_message_new_addrlabel(
+ sd_netlink *rtnl,
+ sd_netlink_message **ret,
+ uint16_t nlmsg_type,
+ int ifindex,
+ int ifal_family) {
+
struct ifaddrlblmsg *addrlabel;
int r;
return 0;
}
-int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
+_public_ int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct ifaddrlblmsg *addrlabel;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
+_public_ int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
struct ifaddrlblmsg *addrlabel;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_routing_policy_rule(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifal_family) {
+_public_ int sd_rtnl_message_new_routing_policy_rule(
+ sd_netlink *rtnl,
+ sd_netlink_message **ret,
+ uint16_t nlmsg_type,
+ int ifal_family) {
+
struct fib_rule_hdr *frh;
int r;
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *tos) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *table) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *flags) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint8_t type) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint8_t *type) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message *m, uint8_t len) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message *m, uint8_t *len) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message *m, uint8_t len) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message *m, uint8_t *len) {
+_public_ 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);
return 0;
}
-int sd_rtnl_message_new_traffic_control(
+_public_ int sd_rtnl_message_new_traffic_control(
sd_netlink *rtnl,
sd_netlink_message **ret,
uint16_t nlmsg_type,
return 0;
}
-int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) {
+_public_ int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) {
struct tcmsg *tcm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret) {
+_public_ int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret) {
struct tcmsg *tcm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret) {
+_public_ int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret) {
struct tcmsg *tcm;
assert_return(m, -EINVAL);
return 0;
}
-int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int mdb_ifindex) {
+_public_ int sd_rtnl_message_new_mdb(
+ sd_netlink *rtnl,
+ sd_netlink_message **ret,
+ uint16_t nlmsg_type,
+ int mdb_ifindex) {
+
struct br_port_msg *bpm;
int r;
return 0;
}
-int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) {
+_public_ int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) {
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(m->protocol != NETLINK_ROUTE ||
DEFINE_TRIVIAL_REF_FUNC(sd_netlink_message, sd_netlink_message);
-sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m) {
+_public_ sd_netlink_message* sd_netlink_message_unref(sd_netlink_message *m) {
while (m && --m->n_ref == 0) {
unsigned i;
return NULL;
}
-int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) {
+_public_ int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) {
assert_return(m, -EINVAL);
assert_return(type != 0, -EINVAL);
return 0;
}
-int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) {
+_public_ int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) {
assert_return(m, -EINVAL);
assert_return(flags != 0, -EINVAL);
return 0;
}
-int sd_netlink_message_is_broadcast(sd_netlink_message *m) {
+_public_ int sd_netlink_message_is_broadcast(sd_netlink_message *m) {
assert_return(m, -EINVAL);
return m->multicast_group != 0;
return 0;
}
-int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data) {
+_public_ int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data) {
size_t length, size;
int r;
return 0;
}
-int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, char * const *data) {
+_public_ int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, char * const *data) {
size_t length, size;
int r;
return 0;
}
-int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type) {
+_public_ int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type) {
size_t size;
int r;
return 0;
}
-int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data) {
+_public_ int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data) {
+_public_ int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data) {
+_public_ int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, uint64_t data) {
+_public_ int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, uint64_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int8_t data) {
+_public_ int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int8_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, int16_t data) {
+_public_ int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, int16_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, int32_t data) {
+_public_ int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, int32_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, int64_t data) {
+_public_ int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, int64_t data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_data(sd_netlink_message *m, unsigned short type, const void *data, size_t len) {
+_public_ int sd_netlink_message_append_data(sd_netlink_message *m, unsigned short type, const void *data, size_t len) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data) {
+_public_ int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data) {
return netlink_message_append_in_addr_union(m, type, AF_INET, (const union in_addr_union *) data);
}
-int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data) {
+_public_ int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data) {
return netlink_message_append_in_addr_union(m, type, AF_INET6, (const union in_addr_union *) data);
}
return 0;
}
-int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, unsigned short type, const struct sockaddr_in *data) {
+_public_ int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, unsigned short type, const struct sockaddr_in *data) {
return netlink_message_append_sockaddr_union(m, type, (const union sockaddr_union *) data);
}
-int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, unsigned short type, const struct sockaddr_in6 *data) {
+_public_ int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, unsigned short type, const struct sockaddr_in6 *data) {
return netlink_message_append_sockaddr_union(m, type, (const union sockaddr_union *) data);
}
-int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data) {
+_public_ int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
+_public_ int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type) {
+_public_ int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type) {
size_t size;
int r;
return 0;
}
-int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key) {
+_public_ int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key) {
const NLTypeSystemUnion *type_system_union;
int r;
return 0;
}
-int sd_netlink_message_close_container(sd_netlink_message *m) {
+_public_ int sd_netlink_message_close_container(sd_netlink_message *m) {
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(m->n_containers > 0, -EINVAL);
return 0;
}
-int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type) {
+_public_ int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_netlink_message_cancel_array(sd_netlink_message *m) {
+_public_ int sd_netlink_message_cancel_array(sd_netlink_message *m) {
uint32_t rta_len;
assert_return(m, -EINVAL);
return RTA_PAYLOAD(rta);
}
-int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t size, void *data) {
+_public_ int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t size, void *data) {
void *attr_data;
int r;
return r;
}
-int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) {
+_public_ int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) {
void *attr_data;
int r;
return r;
}
-int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) {
+_public_ int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) {
void *attr_data;
int r;
return r;
}
-int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short type, char **data) {
+_public_ int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short type, char **data) {
void *attr_data;
int r;
return 0;
}
-int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data) {
+_public_ int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data) {
void *attr_data;
int r;
return 0;
}
-int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data) {
+_public_ int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data) {
void *attr_data;
int r;
return 0;
}
-int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) {
+_public_ int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) {
void *attr_data;
bool net_byteorder;
int r;
return 0;
}
-int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data) {
+_public_ int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data) {
void *attr_data;
bool net_byteorder;
int r;
return 0;
}
-int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data) {
+_public_ int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data) {
void *attr_data;
int r;
return 0;
}
-int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info) {
+_public_ int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info) {
void *attr_data;
int r;
return 0;
}
-int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data) {
+_public_ int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data) {
union in_addr_union u;
int r;
return r;
}
-int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data) {
+_public_ int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data) {
union in_addr_union u;
int r;
return r;
}
-int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type) {
+_public_ int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type) {
void *attr_data;
int r;
return 1;
}
-int sd_netlink_message_read_strv(sd_netlink_message *m, unsigned short container_type, unsigned short type_id, char ***ret) {
+_public_ int sd_netlink_message_read_strv(sd_netlink_message *m, unsigned short container_type, unsigned short type_id, char ***ret) {
_cleanup_strv_free_ char **s = NULL;
const NLTypeSystem *type_system;
const NLType *nl_type;
return 0;
}
-int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type_id) {
+_public_ int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type_id) {
const NLType *nl_type;
const NLTypeSystem *type_system;
void *container;
return 0;
}
-int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type_id) {
+_public_ int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type_id) {
void *container;
size_t size;
int r;
return 0;
}
-int sd_netlink_message_exit_container(sd_netlink_message *m) {
+_public_ int sd_netlink_message_exit_container(sd_netlink_message *m) {
assert_return(m, -EINVAL);
assert_return(m->sealed, -EINVAL);
assert_return(m->n_containers > 0, -EINVAL);
return 0;
}
-int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) {
+_public_ int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) {
assert_return(m, -EINVAL);
assert_return(m->sealed, -EINVAL);
assert_return(ret, -EINVAL);
return 0;
}
-uint32_t message_get_serial(sd_netlink_message *m) {
- assert(m);
- assert(m->hdr);
-
- return m->hdr->nlmsg_seq;
-}
-
-int sd_netlink_message_is_error(sd_netlink_message *m) {
+_public_ int sd_netlink_message_is_error(sd_netlink_message *m) {
assert_return(m, 0);
assert_return(m->hdr, 0);
return m->hdr->nlmsg_type == NLMSG_ERROR;
}
-int sd_netlink_message_get_errno(sd_netlink_message *m) {
+_public_ int sd_netlink_message_get_errno(sd_netlink_message *m) {
struct nlmsgerr *err;
assert_return(m, -EINVAL);
NLMSG_PAYLOAD(m->hdr, hlen));
}
-int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl) {
+_public_ int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl) {
size_t size;
int r;
#include "socket-util.h"
#include "util.h"
-int socket_open(int family) {
- int fd;
-
- fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, family);
- if (fd < 0)
- return -errno;
-
- return fd_move_above_stdio(fd);
-}
-
static int broadcast_groups_get(sd_netlink *nl) {
_cleanup_free_ uint32_t *groups = NULL;
socklen_t len = 0, old_len;
return k;
}
-int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount) {
- _cleanup_free_ struct iovec *iovs = NULL;
- ssize_t k;
-
- assert(nl);
- assert(m);
- assert(msgcount > 0);
-
- iovs = new(struct iovec, msgcount);
- if (!iovs)
- return -ENOMEM;
-
- for (size_t i = 0; i < msgcount; i++) {
- assert(m[i]->hdr);
- assert(m[i]->hdr->nlmsg_len > 0);
-
- iovs[i] = IOVEC_MAKE(m[i]->hdr, m[i]->hdr->nlmsg_len);
- }
-
- k = writev(nl->fd, iovs, msgcount);
- if (k < 0)
- return -errno;
-
- return k;
-}
-
static int socket_recv_message(int fd, struct iovec *iov, uint32_t *ret_mcast_group, bool peek) {
union sockaddr_union sender;
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct nl_pktinfo))) control;
#include "sd-netlink.h"
+#include "fd-util.h"
#include "format-util.h"
+#include "io-util.h"
#include "memory-util.h"
#include "netlink-internal.h"
#include "netlink-util.h"
#include "parse-util.h"
+#include "process-util.h"
#include "strv.h"
int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name) {
*ret = TAKE_PTR(set);
return 0;
}
+
+bool netlink_pid_changed(sd_netlink *nl) {
+ /* We don't support people creating an nl connection and
+ * keeping it around over a fork(). Let's complain. */
+ return ASSERT_PTR(nl)->original_pid != getpid_cached();
+}
+
+static int socket_open(int family) {
+ int fd;
+
+ fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, family);
+ if (fd < 0)
+ return -errno;
+
+ return fd_move_above_stdio(fd);
+}
+
+int netlink_open_family(sd_netlink **ret, int family) {
+ _cleanup_close_ int fd = -1;
+ int r;
+
+ fd = socket_open(family);
+ if (fd < 0)
+ return fd;
+
+ r = sd_netlink_open_fd(ret, fd);
+ if (r < 0)
+ return r;
+ TAKE_FD(fd);
+
+ return 0;
+}
+
+void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m) {
+ uint32_t picked;
+
+ assert(nl);
+ assert(!netlink_pid_changed(nl));
+ assert(m);
+ assert(m->hdr);
+
+ /* Avoid collisions with outstanding requests */
+ do {
+ picked = nl->serial;
+
+ /* Don't use seq == 0, as that is used for broadcasts, so we would get confused by replies to
+ such messages */
+ nl->serial = nl->serial == UINT32_MAX ? 1 : nl->serial + 1;
+
+ } while (hashmap_contains(nl->reply_callbacks, UINT32_TO_PTR(picked)));
+
+ m->hdr->nlmsg_seq = picked;
+ message_seal(m);
+}
+
+static int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount) {
+ _cleanup_free_ struct iovec *iovs = NULL;
+ ssize_t k;
+
+ assert(nl);
+ assert(m);
+ assert(msgcount > 0);
+
+ iovs = new(struct iovec, msgcount);
+ if (!iovs)
+ return -ENOMEM;
+
+ for (size_t i = 0; i < msgcount; i++) {
+ assert(m[i]->hdr);
+ assert(m[i]->hdr->nlmsg_len > 0);
+
+ iovs[i] = IOVEC_MAKE(m[i]->hdr, m[i]->hdr->nlmsg_len);
+ }
+
+ k = writev(nl->fd, iovs, msgcount);
+ if (k < 0)
+ return -errno;
+
+ return k;
+}
+
+int sd_netlink_sendv(
+ sd_netlink *nl,
+ sd_netlink_message **messages,
+ size_t msgcount,
+ uint32_t **ret_serial) {
+
+ _cleanup_free_ uint32_t *serials = NULL;
+ int r;
+
+ assert_return(nl, -EINVAL);
+ assert_return(!netlink_pid_changed(nl), -ECHILD);
+ assert_return(messages, -EINVAL);
+ assert_return(msgcount > 0, -EINVAL);
+
+ if (ret_serial) {
+ serials = new(uint32_t, msgcount);
+ if (!serials)
+ return -ENOMEM;
+ }
+
+ for (size_t i = 0; i < msgcount; i++) {
+ assert_return(!messages[i]->sealed, -EPERM);
+
+ netlink_seal_message(nl, messages[i]);
+ if (serials)
+ serials[i] = message_get_serial(messages[i]);
+ }
+
+ r = socket_writev_message(nl, messages, msgcount);
+ if (r < 0)
+ return r;
+
+ if (ret_serial)
+ *ret_serial = TAKE_PTR(serials);
+
+ return r;
+}
int rtattr_append_attribute(struct rtattr **rta, unsigned short type, const void *data, size_t data_length);
int rtattr_read_nexthop(const struct rtnexthop *rtnh, size_t size, int family, OrderedSet **ret);
+
+void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m);
+
+/* TODO: to be exported later */
+int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, uint32_t **ret_serial);
#include "netlink-genl.h"
#include "netlink-internal.h"
#include "netlink-slot.h"
+#include "netlink-util.h"
#include "process-util.h"
#include "socket-util.h"
#include "string-util.h"
return 0;
}
-int sd_netlink_new_from_fd(sd_netlink **ret, int fd) {
+_public_ int sd_netlink_new_from_fd(sd_netlink **ret, int fd) {
_cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL;
socklen_t addrlen;
int r;
return 0;
}
-int sd_netlink_open_fd(sd_netlink **ret, int fd) {
+_public_ int sd_netlink_open_fd(sd_netlink **ret, int fd) {
_cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL;
int r, protocol;
return 0;
}
-int netlink_open_family(sd_netlink **ret, int family) {
- _cleanup_close_ int fd = -1;
- int r;
-
- fd = socket_open(family);
- if (fd < 0)
- return fd;
-
- r = sd_netlink_open_fd(ret, fd);
- if (r < 0)
- return r;
- TAKE_FD(fd);
-
- return 0;
-}
-
-int sd_netlink_open(sd_netlink **ret) {
+_public_ int sd_netlink_open(sd_netlink **ret) {
return netlink_open_family(ret, NETLINK_ROUTE);
}
-bool netlink_pid_changed(sd_netlink *nl) {
- assert(nl);
-
- /* We don't support people creating an nl connection and
- * keeping it around over a fork(). Let's complain. */
-
- return nl->original_pid != getpid_cached();
-}
-
-int sd_netlink_inc_rcvbuf(sd_netlink *nl, size_t size) {
+_public_ int sd_netlink_inc_rcvbuf(sd_netlink *nl, size_t size) {
assert_return(nl, -EINVAL);
assert_return(!netlink_pid_changed(nl), -ECHILD);
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_netlink, sd_netlink, netlink_free);
-static void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m) {
- uint32_t picked;
-
- assert(nl);
- assert(!netlink_pid_changed(nl));
- assert(m);
- assert(m->hdr);
-
- /* Avoid collisions with outstanding requests */
- do {
- picked = nl->serial;
-
- /* Don't use seq == 0, as that is used for broadcasts, so we would get confused by replies to
- such messages */
- nl->serial = nl->serial == UINT32_MAX ? 1 : nl->serial + 1;
-
- } while (hashmap_contains(nl->reply_callbacks, UINT32_TO_PTR(picked)));
-
- m->hdr->nlmsg_seq = picked;
- message_seal(m);
-}
-
-int sd_netlink_send(
+_public_ int sd_netlink_send(
sd_netlink *nl,
sd_netlink_message *message,
uint32_t *serial) {
return 1;
}
-int sd_netlink_sendv(
- sd_netlink *nl,
- sd_netlink_message **messages,
- size_t msgcount,
- uint32_t **ret_serial) {
-
- _cleanup_free_ uint32_t *serials = NULL;
- int r;
-
- assert_return(nl, -EINVAL);
- assert_return(!netlink_pid_changed(nl), -ECHILD);
- assert_return(messages, -EINVAL);
- assert_return(msgcount > 0, -EINVAL);
-
- if (ret_serial) {
- serials = new(uint32_t, msgcount);
- if (!serials)
- return -ENOMEM;
- }
-
- for (size_t i = 0; i < msgcount; i++) {
- assert_return(!messages[i]->sealed, -EPERM);
-
- netlink_seal_message(nl, messages[i]);
- if (serials)
- serials[i] = message_get_serial(messages[i]);
- }
-
- r = socket_writev_message(nl, messages, msgcount);
- if (r < 0)
- return r;
-
- if (ret_serial)
- *ret_serial = TAKE_PTR(serials);
-
- return r;
-}
-
int netlink_rqueue_make_room(sd_netlink *nl) {
assert(nl);
return CMP(x->timeout, y->timeout);
}
-int sd_netlink_call_async(
+_public_ int sd_netlink_call_async(
sd_netlink *nl,
sd_netlink_slot **ret_slot,
sd_netlink_message *m,
return k;
}
-int sd_netlink_read(
+_public_ int sd_netlink_read(
sd_netlink *nl,
uint32_t serial,
uint64_t usec,
}
}
-int sd_netlink_call(
+_public_ int sd_netlink_call(
sd_netlink *nl,
sd_netlink_message *message,
uint64_t usec,
return sd_netlink_read(nl, serial, usec, ret);
}
-int sd_netlink_get_events(sd_netlink *nl) {
+_public_ int sd_netlink_get_events(sd_netlink *nl) {
assert_return(nl, -EINVAL);
assert_return(!netlink_pid_changed(nl), -ECHILD);
return nl->rqueue_size == 0 ? POLLIN : 0;
}
-int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout_usec) {
+_public_ int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout_usec) {
struct reply_callback *c;
assert_return(nl, -EINVAL);
return 1;
}
-int sd_netlink_attach_event(sd_netlink *nl, sd_event *event, int64_t priority) {
+_public_ int sd_netlink_attach_event(sd_netlink *nl, sd_event *event, int64_t priority) {
int r;
assert_return(nl, -EINVAL);
return r;
}
-int sd_netlink_detach_event(sd_netlink *nl) {
+_public_ int sd_netlink_detach_event(sd_netlink *nl) {
assert_return(nl, -EINVAL);
assert_return(nl->event, -ENXIO);
return 0;
}
-int sd_netlink_add_match(
+_public_ int sd_netlink_add_match(
sd_netlink *rtnl,
sd_netlink_slot **ret_slot,
uint16_t type,
destroy_callback, userdata, description);
}
-int sd_netlink_attach_filter(sd_netlink *nl, size_t len, struct sock_filter *filter) {
+_public_ int sd_netlink_attach_filter(sd_netlink *nl, size_t len, struct sock_filter *filter) {
assert_return(nl, -EINVAL);
assert_return(len == 0 || filter, -EINVAL);
#include "firewall-util-private.h"
#include "in-addr-util.h"
#include "macro.h"
+#include "netlink-internal.h"
+#include "netlink-util.h"
#include "socket-util.h"
#include "time-util.h"
'sd-journal.h',
'sd-login.h',
'sd-messages.h',
+ 'sd-netlink.h',
'sd-path.h',
]
'sd-lldp-tx.h',
'sd-lldp.h',
'sd-ndisc.h',
- 'sd-netlink.h',
'sd-network.h',
'sd-radv.h',
'sd-resolve.h',
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_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, 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 destoy_callback,
void *userdata, uint64_t usec, const char *description);
int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int mdb_ifindex);
-/* nfnl */
-int sd_nfnl_socket_open(sd_netlink **ret);
-int sd_nfnl_message_batch_begin(sd_netlink *nfnl, sd_netlink_message **ret);
-int sd_nfnl_message_batch_end(sd_netlink *nfnl, sd_netlink_message **ret);
-int sd_nfnl_nft_message_del_table(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table);
-int sd_nfnl_nft_message_new_table(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table);
-int sd_nfnl_nft_message_new_basechain(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table, const char *chain,
- const char *type, uint8_t hook, int prio);
-int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table, const char *chain);
-int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table, const char *set_name,
- uint32_t setid, uint32_t klen);
-int sd_nfnl_nft_message_new_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table, const char *set_name);
-int sd_nfnl_nft_message_del_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret,
- int family, const char *table, const char *set_name);
-int sd_nfnl_nft_message_add_setelem(sd_netlink_message *m,
- uint32_t num,
- const void *key, uint32_t klen,
- const void *data, uint32_t dlen);
-int sd_nfnl_nft_message_add_setelem_end(sd_netlink_message *m);
-
/* genl */
int sd_genl_socket_open(sd_netlink **ret);
int sd_genl_message_new(sd_netlink *genl, const char *family_name, uint8_t cmd, sd_netlink_message **ret);
projects / thirdparty / systemd.git / commitdiff
