mirror of
https://github.com/morgan9e/systemd
synced 2026-04-14 00:14:32 +09:00
Merge pull request #34699 from yuwata/netlink-cleanups
sd-netlink: several cleanups
This commit is contained in:
Yu Watanabe
File diff suppressed because it is too large
Load Diff
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 */
|
||||
|
||||
@@ -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.");
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user