SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sd-netlink: rename NLType and friends

Browse Source 
In sd-netlink, we use 'type' for naming many variables with different type,
and worst of all, function like `type_get_type()` exists. That makes the
code hard to understood.

Let's rename
- NLType -> NLAPolicy
- NLTypeSystem -> NLAPolicySet
- NLTypeSystemUnion -> NLAPolicySetUnion
- type_get_type() -> policy_get_type()
- type_get_type_system() -> policy_get_policy_set(), and so on.

This also changes the type of attribute taken by e.g.
`sd_netlink_message_append_string()` from `unsigned short` -> `uint16_t`
to make the variable size clearer.
This commit is contained in:
Yu Watanabe
2022-08-06 03:53:51 +09:00
parent 1ab7e2b587
commit ebf404a4d0
11 changed files with 1666 additions and 1671 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libsystemd/sd-netlink/netlink-genl.c
+28 -28
View File
@@ -12,7 +12,7 @@
typedef struct GenericNetlinkFamily {
sd_netlink *genl;
const NLTypeSystem *type_system;
const NLAPolicySet *policy_set;
uint16_t id; /* a.k.a nlmsg_type */
char *name;
@@ -56,14 +56,14 @@ void genl_clear_family(sd_netlink *nl) {
static int genl_family_new_unsupported(
sd_netlink *nl,
const char *family_name,
const NLTypeSystem *type_system) {
const NLAPolicySet *policy_set) {
_cleanup_(genl_family_freep) GenericNetlinkFamily *f = NULL;
int r;
assert(nl);
assert(family_name);
assert(type_system);
assert(policy_set);
/* Kernel does not support the genl family? To prevent from resolving the family name again,
* let's store the family with zero id to indicate that. */
@@ -73,7 +73,7 @@ static int genl_family_new_unsupported(
return -ENOMEM;
*f = (GenericNetlinkFamily) {
.type_system = type_system,
.policy_set = policy_set,
};
f->name = strdup(family_name);
@@ -92,7 +92,7 @@ static int genl_family_new_unsupported(
static int genl_family_new(
sd_netlink *nl,
const char *expected_family_name,
const NLTypeSystem *type_system,
const NLAPolicySet *policy_set,
sd_netlink_message *message,
const GenericNetlinkFamily **ret) {
@@ -103,7 +103,7 @@ static int genl_family_new(
assert(nl);
assert(expected_family_name);
assert(type_system);
assert(policy_set);
assert(message);
assert(ret);
@@ -112,7 +112,7 @@ static int genl_family_new(
return -ENOMEM;
*f = (GenericNetlinkFamily) {
.type_system = type_system,
.policy_set = policy_set,
};
r = sd_genl_message_get_family_name(nl, message, &family_name);
@@ -205,13 +205,13 @@ static int genl_family_new(
return 0;
}
static const NLTypeSystem *genl_family_get_type_system(const GenericNetlinkFamily *family) {
static const NLAPolicySet *genl_family_get_policy_set(const GenericNetlinkFamily *family) {
assert(family);
if (family->type_system)
return family->type_system;
if (family->policy_set)
return family->policy_set;
return genl_get_type_system_by_name(family->name);
return genl_get_policy_set_by_name(family->name);
}
static int genl_message_new(
@@ -221,7 +221,7 @@ static int genl_message_new(
sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
const NLTypeSystem *type_system;
const NLAPolicySet *policy_set;
int r;
assert(nl);
@@ -229,11 +229,11 @@ static int genl_message_new(
assert(family);
assert(ret);
type_system = genl_family_get_type_system(family);
if (!type_system)
policy_set = genl_family_get_policy_set(family);
if (!policy_set)
return -EOPNOTSUPP;
r = message_new_full(nl, family->id, type_system,
r = message_new_full(nl, family->id, policy_set,
sizeof(struct genlmsghdr) + family->additional_header_size, &m);
if (r < 0)
return r;
@@ -254,7 +254,7 @@ static int genl_family_get_by_name_internal(
const GenericNetlinkFamily **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
const NLTypeSystem *type_system;
const NLAPolicySet *policy_set;
int r;
assert(nl);
@@ -263,8 +263,8 @@ static int genl_family_get_by_name_internal(
assert(name);
assert(ret);
type_system = genl_get_type_system_by_name(name);
if (!type_system)
policy_set = genl_get_policy_set_by_name(name);
if (!policy_set)
return -EOPNOTSUPP;
r = genl_message_new(nl, ctrl, CTRL_CMD_GETFAMILY, &req);
@@ -276,11 +276,11 @@ static int genl_family_get_by_name_internal(
return r;
if (sd_netlink_call(nl, req, 0, &reply) < 0) {
(void) genl_family_new_unsupported(nl, name, type_system);
(void) genl_family_new_unsupported(nl, name, policy_set);
return -EOPNOTSUPP;
}
return genl_family_new(nl, name, type_system, reply, ret);
return genl_family_new(nl, name, policy_set, reply, ret);
}
static int genl_family_get_by_name(sd_netlink *nl, const char *name, const GenericNetlinkFamily **ret) {
@@ -335,10 +335,10 @@ static int genl_family_get_by_id(sd_netlink *nl, uint16_t id, const GenericNetli
return -ENOENT;
}
int genl_get_type_system_and_header_size(
int genl_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t id,
const NLTypeSystem **ret_type_system,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size) {
const GenericNetlinkFamily *f;
@@ -351,14 +351,14 @@ int genl_get_type_system_and_header_size(
if (r < 0)
return r;
if (ret_type_system) {
const NLTypeSystem *t;
if (ret_policy_set) {
const NLAPolicySet *p;
t = genl_family_get_type_system(f);
if (!t)
p = genl_family_get_policy_set(f);
if (!p)
return -EOPNOTSUPP;
*ret_type_system = t;
*ret_policy_set = p;
}
if (ret_header_size)
*ret_header_size = sizeof(struct genlmsghdr) + f->additional_header_size;
@@ -420,7 +420,7 @@ _public_ int sd_genl_message_get_command(sd_netlink *nl, sd_netlink_message *m,
if (r < 0)
return r;
r = genl_get_type_system_and_header_size(nl, nlmsg_type, NULL, &size);
r = genl_get_policy_set_and_header_size(nl, nlmsg_type, NULL, &size);
if (r < 0)
return r;
src/libsystemd/sd-netlink/netlink-internal.h
+2 -2
View File
@@ -109,7 +109,7 @@ struct netlink_attribute {
};
struct netlink_container {
const struct NLTypeSystem *type_system; /* the type system of the container */
const struct NLAPolicySet *policy_set; /* the policy set of the container */
size_t offset; /* offset from hdr to the start of the container */
struct netlink_attribute *attributes;
uint16_t max_attribute; /* the maximum attribute in container */
@@ -133,7 +133,7 @@ int message_new_empty(sd_netlink *nl, sd_netlink_message **ret);
int message_new_full(
sd_netlink *nl,
uint16_t nlmsg_type,
const NLTypeSystem *type_system,
const NLAPolicySet *policy_set,
size_t header_size,
sd_netlink_message **ret);
int message_new(sd_netlink *nl, sd_netlink_message **ret, uint16_t type);
src/libsystemd/sd-netlink/netlink-message.c
+233 -238
View File
File diff suppressed because it is too large Load Diff
src/libsystemd/sd-netlink/netlink-socket.c
+1 -1
View File
@@ -308,7 +308,7 @@ int socket_read_message(sd_netlink *nl) {
}
/* check that we support this message type */
r = type_system_root_get_type_system_and_header_size(nl, new_msg->nlmsg_type, NULL, &size);
r = netlink_get_policy_set_and_header_size(nl, new_msg->nlmsg_type, NULL, &size);
if (r < 0) {
if (r == -EOPNOTSUPP)
log_debug("sd-netlink: ignored message with unknown type: %i",
src/libsystemd/sd-netlink/netlink-types-genl.c
+174 -174
View File
@@ -16,225 +16,225 @@
#include "netlink-types-internal.h"
/***************** genl ctrl type systems *****************/
static const NLType genl_ctrl_mcast_group_types[] = {
[CTRL_ATTR_MCAST_GRP_NAME] = { .type = NETLINK_TYPE_STRING },
[CTRL_ATTR_MCAST_GRP_ID] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy genl_ctrl_mcast_group_policies[] = {
[CTRL_ATTR_MCAST_GRP_NAME] = BUILD_POLICY(STRING),
[CTRL_ATTR_MCAST_GRP_ID] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(genl_ctrl_mcast_group);
DEFINE_POLICY_SET(genl_ctrl_mcast_group);
static const NLType genl_ctrl_ops_types[] = {
[CTRL_ATTR_OP_ID] = { .type = NETLINK_TYPE_U32 },
[CTRL_ATTR_OP_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy genl_ctrl_ops_policies[] = {
[CTRL_ATTR_OP_ID] = BUILD_POLICY(U32),
[CTRL_ATTR_OP_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(genl_ctrl_ops);
DEFINE_POLICY_SET(genl_ctrl_ops);
static const NLType genl_ctrl_types[] = {
[CTRL_ATTR_FAMILY_ID] = { .type = NETLINK_TYPE_U16 },
[CTRL_ATTR_FAMILY_NAME] = { .type = NETLINK_TYPE_STRING },
[CTRL_ATTR_VERSION] = { .type = NETLINK_TYPE_U32 },
[CTRL_ATTR_HDRSIZE] = { .type = NETLINK_TYPE_U32 },
[CTRL_ATTR_MAXATTR] = { .type = NETLINK_TYPE_U32 },
[CTRL_ATTR_OPS] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_ctrl_ops_type_system },
[CTRL_ATTR_MCAST_GROUPS] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_ctrl_mcast_group_type_system },
static const NLAPolicy genl_ctrl_policies[] = {
[CTRL_ATTR_FAMILY_ID] = BUILD_POLICY(U16),
[CTRL_ATTR_FAMILY_NAME] = BUILD_POLICY(STRING),
[CTRL_ATTR_VERSION] = BUILD_POLICY(U32),
[CTRL_ATTR_HDRSIZE] = BUILD_POLICY(U32),
[CTRL_ATTR_MAXATTR] = BUILD_POLICY(U32),
[CTRL_ATTR_OPS] = BUILD_POLICY_NESTED(genl_ctrl_ops),
[CTRL_ATTR_MCAST_GROUPS] = BUILD_POLICY_NESTED(genl_ctrl_mcast_group),
/*
[CTRL_ATTR_POLICY] = { .type = NETLINK_TYPE_NESTED, },
[CTRL_ATTR_OP_POLICY] = { .type = NETLINK_TYPE_NESTED, }
*/
[CTRL_ATTR_OP] = { .type = NETLINK_TYPE_U32 },
[CTRL_ATTR_OP] = BUILD_POLICY(U32),
};
/***************** genl batadv type systems *****************/
static const NLType genl_batadv_types[] = {
[BATADV_ATTR_VERSION] = { .type = NETLINK_TYPE_STRING },
[BATADV_ATTR_ALGO_NAME] = { .type = NETLINK_TYPE_STRING },
[BATADV_ATTR_MESH_IFINDEX] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_MESH_IFNAME] = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ },
[BATADV_ATTR_MESH_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_HARD_IFINDEX] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_HARD_IFNAME] = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ },
[BATADV_ATTR_HARD_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_ORIG_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_TPMETER_RESULT] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_TPMETER_TEST_TIME] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_TPMETER_BYTES] = { .type = NETLINK_TYPE_U64 },
[BATADV_ATTR_TPMETER_COOKIE] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_PAD] = { .type = NETLINK_TYPE_UNSPEC },
[BATADV_ATTR_ACTIVE] = { .type = NETLINK_TYPE_FLAG },
[BATADV_ATTR_TT_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_TT_TTVN] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_TT_LAST_TTVN] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_TT_CRC32] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_TT_VID] = { .type = NETLINK_TYPE_U16 },
[BATADV_ATTR_TT_FLAGS] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_FLAG_BEST] = { .type = NETLINK_TYPE_FLAG },
[BATADV_ATTR_LAST_SEEN_MSECS] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_NEIGH_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_TQ] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_THROUGHPUT] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_BANDWIDTH_UP] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_BANDWIDTH_DOWN] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_ROUTER] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_BLA_OWN] = { .type = NETLINK_TYPE_FLAG },
[BATADV_ATTR_BLA_ADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_BLA_VID] = { .type = NETLINK_TYPE_U16 },
[BATADV_ATTR_BLA_BACKBONE] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_BLA_CRC] = { .type = NETLINK_TYPE_U16 },
[BATADV_ATTR_DAT_CACHE_IP4ADDRESS] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_DAT_CACHE_HWADDRESS] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[BATADV_ATTR_DAT_CACHE_VID] = { .type = NETLINK_TYPE_U16 },
[BATADV_ATTR_MCAST_FLAGS] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_MCAST_FLAGS_PRIV] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_VLANID] = { .type = NETLINK_TYPE_U16 },
[BATADV_ATTR_AGGREGATED_OGMS_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_AP_ISOLATION_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_ISOLATION_MARK] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_ISOLATION_MASK] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_BONDING_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_FRAGMENTATION_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_GW_BANDWIDTH_DOWN] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_GW_BANDWIDTH_UP] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_GW_MODE] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_GW_SEL_CLASS] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_HOP_PENALTY] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_LOG_LEVEL] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_MULTICAST_FANOUT] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_NETWORK_CODING_ENABLED] = { .type = NETLINK_TYPE_U8 },
[BATADV_ATTR_ORIG_INTERVAL] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_ELP_INTERVAL] = { .type = NETLINK_TYPE_U32 },
[BATADV_ATTR_THROUGHPUT_OVERRIDE] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy genl_batadv_policies[] = {
[BATADV_ATTR_VERSION] = BUILD_POLICY(STRING),
[BATADV_ATTR_ALGO_NAME] = BUILD_POLICY(STRING),
[BATADV_ATTR_MESH_IFINDEX] = BUILD_POLICY(U32),
[BATADV_ATTR_MESH_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ),
[BATADV_ATTR_MESH_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_HARD_IFINDEX] = BUILD_POLICY(U32),
[BATADV_ATTR_HARD_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ),
[BATADV_ATTR_HARD_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_ORIG_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TPMETER_RESULT] = BUILD_POLICY(U8),
[BATADV_ATTR_TPMETER_TEST_TIME] = BUILD_POLICY(U32),
[BATADV_ATTR_TPMETER_BYTES] = BUILD_POLICY(U64),
[BATADV_ATTR_TPMETER_COOKIE] = BUILD_POLICY(U32),
[BATADV_ATTR_PAD] = BUILD_POLICY(UNSPEC),
[BATADV_ATTR_ACTIVE] = BUILD_POLICY(FLAG),
[BATADV_ATTR_TT_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TT_TTVN] = BUILD_POLICY(U8),
[BATADV_ATTR_TT_LAST_TTVN] = BUILD_POLICY(U8),
[BATADV_ATTR_TT_CRC32] = BUILD_POLICY(U32),
[BATADV_ATTR_TT_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_TT_FLAGS] = BUILD_POLICY(U32),
[BATADV_ATTR_FLAG_BEST] = BUILD_POLICY(FLAG),
[BATADV_ATTR_LAST_SEEN_MSECS] = BUILD_POLICY(U32),
[BATADV_ATTR_NEIGH_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TQ] = BUILD_POLICY(U8),
[BATADV_ATTR_THROUGHPUT] = BUILD_POLICY(U32),
[BATADV_ATTR_BANDWIDTH_UP] = BUILD_POLICY(U32),
[BATADV_ATTR_BANDWIDTH_DOWN] = BUILD_POLICY(U32),
[BATADV_ATTR_ROUTER] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_OWN] = BUILD_POLICY(FLAG),
[BATADV_ATTR_BLA_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_BLA_BACKBONE] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_CRC] = BUILD_POLICY(U16),
[BATADV_ATTR_DAT_CACHE_IP4ADDRESS] = BUILD_POLICY(U32),
[BATADV_ATTR_DAT_CACHE_HWADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_DAT_CACHE_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_MCAST_FLAGS] = BUILD_POLICY(U32),
[BATADV_ATTR_MCAST_FLAGS_PRIV] = BUILD_POLICY(U32),
[BATADV_ATTR_VLANID] = BUILD_POLICY(U16),
[BATADV_ATTR_AGGREGATED_OGMS_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_AP_ISOLATION_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_ISOLATION_MARK] = BUILD_POLICY(U32),
[BATADV_ATTR_ISOLATION_MASK] = BUILD_POLICY(U32),
[BATADV_ATTR_BONDING_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_FRAGMENTATION_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_GW_BANDWIDTH_DOWN] = BUILD_POLICY(U32),
[BATADV_ATTR_GW_BANDWIDTH_UP] = BUILD_POLICY(U32),
[BATADV_ATTR_GW_MODE] = BUILD_POLICY(U8),
[BATADV_ATTR_GW_SEL_CLASS] = BUILD_POLICY(U32),
[BATADV_ATTR_HOP_PENALTY] = BUILD_POLICY(U8),
[BATADV_ATTR_LOG_LEVEL] = BUILD_POLICY(U32),
[BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_MULTICAST_FANOUT] = BUILD_POLICY(U32),
[BATADV_ATTR_NETWORK_CODING_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_ORIG_INTERVAL] = BUILD_POLICY(U32),
[BATADV_ATTR_ELP_INTERVAL] = BUILD_POLICY(U32),
[BATADV_ATTR_THROUGHPUT_OVERRIDE] = BUILD_POLICY(U32),
};
/***************** genl fou type systems *****************/
static const NLType genl_fou_types[] = {
[FOU_ATTR_PORT] = { .type = NETLINK_TYPE_U16 },
[FOU_ATTR_AF] = { .type = NETLINK_TYPE_U8 },
[FOU_ATTR_IPPROTO] = { .type = NETLINK_TYPE_U8 },
[FOU_ATTR_TYPE] = { .type = NETLINK_TYPE_U8 },
[FOU_ATTR_REMCSUM_NOPARTIAL] = { .type = NETLINK_TYPE_FLAG },
[FOU_ATTR_LOCAL_V4] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in_addr) },
[FOU_ATTR_PEER_V4] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in_addr) },
[FOU_ATTR_LOCAL_V6] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in6_addr) },
[FOU_ATTR_PEER_V6] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in6_addr) },
[FOU_ATTR_PEER_PORT] = { .type = NETLINK_TYPE_U16 },
[FOU_ATTR_IFINDEX] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy genl_fou_policies[] = {
[FOU_ATTR_PORT] = BUILD_POLICY(U16),
[FOU_ATTR_AF] = BUILD_POLICY(U8),
[FOU_ATTR_IPPROTO] = BUILD_POLICY(U8),
[FOU_ATTR_TYPE] = BUILD_POLICY(U8),
[FOU_ATTR_REMCSUM_NOPARTIAL] = BUILD_POLICY(FLAG),
[FOU_ATTR_LOCAL_V4] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[FOU_ATTR_PEER_V4] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[FOU_ATTR_LOCAL_V6] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[FOU_ATTR_PEER_V6] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[FOU_ATTR_PEER_PORT] = BUILD_POLICY(U16),
[FOU_ATTR_IFINDEX] = BUILD_POLICY(U32),
};
/***************** genl l2tp type systems *****************/
static const NLType genl_l2tp_types[] = {
[L2TP_ATTR_PW_TYPE] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_ENCAP_TYPE] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_OFFSET] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_DATA_SEQ] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_L2SPEC_TYPE] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_L2SPEC_LEN] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_PROTO_VERSION] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_IFNAME] = { .type = NETLINK_TYPE_STRING },
[L2TP_ATTR_CONN_ID] = { .type = NETLINK_TYPE_U32 },
[L2TP_ATTR_PEER_CONN_ID] = { .type = NETLINK_TYPE_U32 },
[L2TP_ATTR_SESSION_ID] = { .type = NETLINK_TYPE_U32 },
[L2TP_ATTR_PEER_SESSION_ID] = { .type = NETLINK_TYPE_U32 },
[L2TP_ATTR_UDP_CSUM] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_VLAN_ID] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_RECV_SEQ] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_SEND_SEQ] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_LNS_MODE] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_USING_IPSEC] = { .type = NETLINK_TYPE_U8 },
[L2TP_ATTR_FD] = { .type = NETLINK_TYPE_U32 },
[L2TP_ATTR_IP_SADDR] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in_addr) },
[L2TP_ATTR_IP_DADDR] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in_addr) },
[L2TP_ATTR_UDP_SPORT] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_UDP_DPORT] = { .type = NETLINK_TYPE_U16 },
[L2TP_ATTR_IP6_SADDR] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in6_addr) },
[L2TP_ATTR_IP6_DADDR] = { .type = NETLINK_TYPE_IN_ADDR, .size = sizeof(struct in6_addr) },
[L2TP_ATTR_UDP_ZERO_CSUM6_TX] = { .type = NETLINK_TYPE_FLAG },
[L2TP_ATTR_UDP_ZERO_CSUM6_RX] = { .type = NETLINK_TYPE_FLAG },
static const NLAPolicy genl_l2tp_policies[] = {
[L2TP_ATTR_PW_TYPE] = BUILD_POLICY(U16),
[L2TP_ATTR_ENCAP_TYPE] = BUILD_POLICY(U16),
[L2TP_ATTR_OFFSET] = BUILD_POLICY(U16),
[L2TP_ATTR_DATA_SEQ] = BUILD_POLICY(U16),
[L2TP_ATTR_L2SPEC_TYPE] = BUILD_POLICY(U8),
[L2TP_ATTR_L2SPEC_LEN] = BUILD_POLICY(U8),
[L2TP_ATTR_PROTO_VERSION] = BUILD_POLICY(U8),
[L2TP_ATTR_IFNAME] = BUILD_POLICY(STRING),
[L2TP_ATTR_CONN_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_PEER_CONN_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_SESSION_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_PEER_SESSION_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_UDP_CSUM] = BUILD_POLICY(U8),
[L2TP_ATTR_VLAN_ID] = BUILD_POLICY(U16),
[L2TP_ATTR_RECV_SEQ] = BUILD_POLICY(U8),
[L2TP_ATTR_SEND_SEQ] = BUILD_POLICY(U8),
[L2TP_ATTR_LNS_MODE] = BUILD_POLICY(U8),
[L2TP_ATTR_USING_IPSEC] = BUILD_POLICY(U8),
[L2TP_ATTR_FD] = BUILD_POLICY(U32),
[L2TP_ATTR_IP_SADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[L2TP_ATTR_IP_DADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[L2TP_ATTR_UDP_SPORT] = BUILD_POLICY(U16),
[L2TP_ATTR_UDP_DPORT] = BUILD_POLICY(U16),
[L2TP_ATTR_IP6_SADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[L2TP_ATTR_IP6_DADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[L2TP_ATTR_UDP_ZERO_CSUM6_TX] = BUILD_POLICY(FLAG),
[L2TP_ATTR_UDP_ZERO_CSUM6_RX] = BUILD_POLICY(FLAG),
};
/***************** genl macsec type systems *****************/
static const NLType genl_macsec_rxsc_types[] = {
[MACSEC_RXSC_ATTR_SCI] = { .type = NETLINK_TYPE_U64 },
static const NLAPolicy genl_macsec_rxsc_policies[] = {
[MACSEC_RXSC_ATTR_SCI] = BUILD_POLICY(U64),
};
DEFINE_TYPE_SYSTEM(genl_macsec_rxsc);
DEFINE_POLICY_SET(genl_macsec_rxsc);
static const NLType genl_macsec_sa_types[] = {
[MACSEC_SA_ATTR_AN] = { .type = NETLINK_TYPE_U8 },
[MACSEC_SA_ATTR_ACTIVE] = { .type = NETLINK_TYPE_U8 },
[MACSEC_SA_ATTR_PN] = { .type = NETLINK_TYPE_U32 },
[MACSEC_SA_ATTR_KEYID] = { .type = NETLINK_TYPE_BINARY, .size = MACSEC_KEYID_LEN },
[MACSEC_SA_ATTR_KEY] = { .type = NETLINK_TYPE_BINARY, .size = MACSEC_MAX_KEY_LEN },
static const NLAPolicy genl_macsec_sa_policies[] = {
[MACSEC_SA_ATTR_AN] = BUILD_POLICY(U8),
[MACSEC_SA_ATTR_ACTIVE] = BUILD_POLICY(U8),
[MACSEC_SA_ATTR_PN] = BUILD_POLICY(U32),
[MACSEC_SA_ATTR_KEYID] = BUILD_POLICY_WITH_SIZE(BINARY, MACSEC_KEYID_LEN),
[MACSEC_SA_ATTR_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, MACSEC_MAX_KEY_LEN),
};
DEFINE_TYPE_SYSTEM(genl_macsec_sa);
DEFINE_POLICY_SET(genl_macsec_sa);
static const NLType genl_macsec_types[] = {
[MACSEC_ATTR_IFINDEX] = { .type = NETLINK_TYPE_U32 },
[MACSEC_ATTR_RXSC_CONFIG] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_macsec_rxsc_type_system },
[MACSEC_ATTR_SA_CONFIG] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_macsec_sa_type_system },
static const NLAPolicy genl_macsec_policies[] = {
[MACSEC_ATTR_IFINDEX] = BUILD_POLICY(U32),
[MACSEC_ATTR_RXSC_CONFIG] = BUILD_POLICY_NESTED(genl_macsec_rxsc),
[MACSEC_ATTR_SA_CONFIG] = BUILD_POLICY_NESTED(genl_macsec_sa),
};
/***************** genl nl80211 type systems *****************/
static const NLType genl_nl80211_types[] = {
[NL80211_ATTR_WIPHY] = { .type = NETLINK_TYPE_U32 },
[NL80211_ATTR_WIPHY_NAME] = { .type = NETLINK_TYPE_STRING },
[NL80211_ATTR_IFINDEX] = { .type = NETLINK_TYPE_U32 },
[NL80211_ATTR_IFNAME] = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ-1 },
[NL80211_ATTR_IFTYPE] = { .type = NETLINK_TYPE_U32 },
[NL80211_ATTR_MAC] = { .type = NETLINK_TYPE_ETHER_ADDR, .size = ETH_ALEN },
[NL80211_ATTR_SSID] = { .type = NETLINK_TYPE_BINARY, .size = IEEE80211_MAX_SSID_LEN },
[NL80211_ATTR_STATUS_CODE] = { .type = NETLINK_TYPE_U16 },
[NL80211_ATTR_4ADDR] = { .type = NETLINK_TYPE_U8 },
static const NLAPolicy genl_nl80211_policies[] = {
[NL80211_ATTR_WIPHY] = BUILD_POLICY(U32),
[NL80211_ATTR_WIPHY_NAME] = BUILD_POLICY(STRING),
[NL80211_ATTR_IFINDEX] = BUILD_POLICY(U32),
[NL80211_ATTR_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ-1),
[NL80211_ATTR_IFTYPE] = BUILD_POLICY(U32),
[NL80211_ATTR_MAC] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[NL80211_ATTR_SSID] = BUILD_POLICY_WITH_SIZE(BINARY, IEEE80211_MAX_SSID_LEN),
[NL80211_ATTR_STATUS_CODE] = BUILD_POLICY(U16),
[NL80211_ATTR_4ADDR] = BUILD_POLICY(U8),
};
/***************** genl wireguard type systems *****************/
static const NLType genl_wireguard_allowedip_types[] = {
[WGALLOWEDIP_A_FAMILY] = { .type = NETLINK_TYPE_U16 },
[WGALLOWEDIP_A_IPADDR] = { .type = NETLINK_TYPE_IN_ADDR },
[WGALLOWEDIP_A_CIDR_MASK] = { .type = NETLINK_TYPE_U8 },
static const NLAPolicy genl_wireguard_allowedip_policies[] = {
[WGALLOWEDIP_A_FAMILY] = BUILD_POLICY(U16),
[WGALLOWEDIP_A_IPADDR] = BUILD_POLICY(IN_ADDR),
[WGALLOWEDIP_A_CIDR_MASK] = BUILD_POLICY(U8),
};
DEFINE_TYPE_SYSTEM(genl_wireguard_allowedip);
DEFINE_POLICY_SET(genl_wireguard_allowedip);
static const NLType genl_wireguard_peer_types[] = {
[WGPEER_A_PUBLIC_KEY] = { .type = NETLINK_TYPE_BINARY, .size = WG_KEY_LEN },
[WGPEER_A_FLAGS] = { .type = NETLINK_TYPE_U32 },
[WGPEER_A_PRESHARED_KEY] = { .type = NETLINK_TYPE_BINARY, .size = WG_KEY_LEN },
[WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL] = { .type = NETLINK_TYPE_U16 },
[WGPEER_A_ENDPOINT] = { .type = NETLINK_TYPE_SOCKADDR },
[WGPEER_A_ALLOWEDIPS] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_wireguard_allowedip_type_system },
static const NLAPolicy genl_wireguard_peer_policies[] = {
[WGPEER_A_PUBLIC_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGPEER_A_FLAGS] = BUILD_POLICY(U32),
[WGPEER_A_PRESHARED_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL] = BUILD_POLICY(U16),
[WGPEER_A_ENDPOINT] = BUILD_POLICY(SOCKADDR),
[WGPEER_A_ALLOWEDIPS] = BUILD_POLICY_NESTED(genl_wireguard_allowedip),
};
DEFINE_TYPE_SYSTEM(genl_wireguard_peer);
DEFINE_POLICY_SET(genl_wireguard_peer);
static const NLType genl_wireguard_types[] = {
[WGDEVICE_A_IFINDEX] = { .type = NETLINK_TYPE_U32 },
[WGDEVICE_A_IFNAME] = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ-1 },
[WGDEVICE_A_FLAGS] = { .type = NETLINK_TYPE_U32 },
[WGDEVICE_A_PRIVATE_KEY] = { .type = NETLINK_TYPE_BINARY, .size = WG_KEY_LEN },
[WGDEVICE_A_LISTEN_PORT] = { .type = NETLINK_TYPE_U16 },
[WGDEVICE_A_FWMARK] = { .type = NETLINK_TYPE_U32 },
[WGDEVICE_A_PEERS] = { .type = NETLINK_TYPE_NESTED, .type_system = &genl_wireguard_peer_type_system },
static const NLAPolicy genl_wireguard_policies[] = {
[WGDEVICE_A_IFINDEX] = BUILD_POLICY(U32),
[WGDEVICE_A_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ-1),
[WGDEVICE_A_FLAGS] = BUILD_POLICY(U32),
[WGDEVICE_A_PRIVATE_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGDEVICE_A_LISTEN_PORT] = BUILD_POLICY(U16),
[WGDEVICE_A_FWMARK] = BUILD_POLICY(U32),
[WGDEVICE_A_PEERS] = BUILD_POLICY_NESTED(genl_wireguard_peer),
};
/***************** genl families *****************/
static const NLTypeSystemUnionElement genl_type_systems[] = {
{ .name = CTRL_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_ctrl), },
{ .name = BATADV_NL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_batadv), },
{ .name = FOU_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_fou), },
{ .name = L2TP_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_l2tp), },
{ .name = MACSEC_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_macsec), },
{ .name = NL80211_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_nl80211), },
{ .name = WG_GENL_NAME, .type_system = TYPE_SYSTEM_FROM_TYPE(genl_wireguard), },
static const NLAPolicySetUnionElement genl_policy_set_union_elements[] = {
BUILD_UNION_ELEMENT_BY_STRING(CTRL_GENL_NAME, genl_ctrl),
BUILD_UNION_ELEMENT_BY_STRING(BATADV_NL_NAME, genl_batadv),
BUILD_UNION_ELEMENT_BY_STRING(FOU_GENL_NAME, genl_fou),
BUILD_UNION_ELEMENT_BY_STRING(L2TP_GENL_NAME, genl_l2tp),
BUILD_UNION_ELEMENT_BY_STRING(MACSEC_GENL_NAME, genl_macsec),
BUILD_UNION_ELEMENT_BY_STRING(NL80211_GENL_NAME, genl_nl80211),
BUILD_UNION_ELEMENT_BY_STRING(WG_GENL_NAME, genl_wireguard),
};
/* This is the root type system union, so match_attribute is not necessary. */
DEFINE_TYPE_SYSTEM_UNION_MATCH_SIBLING(genl, 0);
DEFINE_POLICY_SET_UNION(genl, 0);
const NLTypeSystem *genl_get_type_system_by_name(const char *name) {
return type_system_union_get_type_system_by_string(&genl_type_system_union, name);
const NLAPolicySet *genl_get_policy_set_by_name(const char *name) {
return policy_set_union_get_policy_set_by_string(&genl_policy_set_union, name);
}
src/libsystemd/sd-netlink/netlink-types-internal.h
+52 -35
View File
@@ -4,46 +4,63 @@
#include "macro.h"
#include "netlink-types.h"
struct NLType {
uint16_t type;
/* C.f. see 'struct nla_policy' at include/net/netlink.h. */
struct NLAPolicy {
NLAType type;
size_t size;
const NLTypeSystem *type_system;
const NLTypeSystemUnion *type_system_union;
};
struct NLTypeSystem {
uint16_t count;
const NLType *types;
};
typedef struct NLTypeSystemUnionElement {
union {
int protocol;
const char *name;
const NLAPolicySet *policy_set;
const NLAPolicySetUnion *policy_set_union;
};
NLTypeSystem type_system;
} NLTypeSystemUnionElement;
struct NLTypeSystemUnion {
size_t count;
const NLTypeSystemUnionElement *elements;
NLMatchType match_type;
uint16_t match_attribute;
};
#define TYPE_SYSTEM_FROM_TYPE(name) \
{ .count = ELEMENTSOF(name##_types), .types = name##_types }
#define DEFINE_TYPE_SYSTEM(name) \
static const NLTypeSystem name##_type_system = TYPE_SYSTEM_FROM_TYPE(name)
struct NLAPolicySet {
uint16_t count;
const NLAPolicy *policies;
};
#define _DEFINE_TYPE_SYSTEM_UNION(name, type, attr) \
static const NLTypeSystemUnion name##_type_system_union = { \
.count = ELEMENTSOF(name##_type_systems), \
.elements = name##_type_systems, \
.match_type = type, \
typedef struct NLAPolicySetUnionElement {
union {
int family; /* used by NETLINK_TYPE_NESTED_UNION_BY_FAMILY */
const char *string; /* used by NETLINK_TYPE_NESTED_UNION_BY_STRING */
};
NLAPolicySet policy_set;
} NLAPolicySetUnionElement;
struct NLAPolicySetUnion {
size_t count;
const NLAPolicySetUnionElement *elements;
uint16_t match_attribute; /* used by NETLINK_TYPE_NESTED_UNION_BY_STRING */
};
#define BUILD_POLICY_WITH_SIZE(t, n) \
{ .type = NETLINK_TYPE_##t, .size = n }
#define BUILD_POLICY(t) \
BUILD_POLICY_WITH_SIZE(t, 0)
#define BUILD_POLICY_NESTED_WITH_SIZE(name, n) \
{ .type = NETLINK_TYPE_NESTED, .size = n, .policy_set = &name##_policy_set }
#define BUILD_POLICY_NESTED(name) \
BUILD_POLICY_NESTED_WITH_SIZE(name, 0)
#define _BUILD_POLICY_NESTED_UNION(name, by) \
{ .type = NETLINK_TYPE_NESTED_UNION_BY_##by, .policy_set_union = &name##_policy_set_union }
#define BUILD_POLICY_NESTED_UNION_BY_STRING(name) \
_BUILD_POLICY_NESTED_UNION(name, STRING)
#define BUILD_POLICY_NESTED_UNION_BY_FAMILY(name) \
_BUILD_POLICY_NESTED_UNION(name, FAMILY)
#define _BUILD_POLICY_SET(name) \
{ .count = ELEMENTSOF(name##_policies), .policies = name##_policies }
#define DEFINE_POLICY_SET(name) \
static const NLAPolicySet name##_policy_set = _BUILD_POLICY_SET(name)
# define BUILD_UNION_ELEMENT_BY_STRING(s, name) \
{ .string = s, .policy_set = _BUILD_POLICY_SET(name) }
# define BUILD_UNION_ELEMENT_BY_FAMILY(f, name) \
{ .family = f, .policy_set = _BUILD_POLICY_SET(name) }
#define DEFINE_POLICY_SET_UNION(name, attr) \
static const NLAPolicySetUnion name##_policy_set_union = { \
.count = ELEMENTSOF(name##_policy_set_union_elements), \
.elements = name##_policy_set_union_elements, \
.match_attribute = attr, \
}
#define DEFINE_TYPE_SYSTEM_UNION_MATCH_PROTOCOL(name) \
_DEFINE_TYPE_SYSTEM_UNION(name, NL_MATCH_PROTOCOL, 0)
#define DEFINE_TYPE_SYSTEM_UNION_MATCH_SIBLING(name, attr) \
_DEFINE_TYPE_SYSTEM_UNION(name, NL_MATCH_SIBLING, attr)
src/libsystemd/sd-netlink/netlink-types-nfnl.c
+121 -124
View File
@@ -1,197 +1,194 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <sys/socket.h>
#include <linux/if.h>
#include <linux/netfilter/nf_tables.h>
#include <linux/netfilter/nfnetlink.h>
#include "netlink-types-internal.h"
#include "string-table.h"
static const NLType nfnl_nft_table_types[] = {
[NFTA_TABLE_NAME] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_TABLE_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_table_policies[] = {
[NFTA_TABLE_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_TABLE_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_table);
DEFINE_POLICY_SET(nfnl_nft_table);
static const NLType nfnl_nft_chain_hook_types[] = {
[NFTA_HOOK_HOOKNUM] = { .type = NETLINK_TYPE_U32 },
[NFTA_HOOK_PRIORITY] = { .type = NETLINK_TYPE_U32 },
[NFTA_HOOK_DEV] = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ - 1 },
static const NLAPolicy nfnl_nft_chain_hook_policies[] = {
[NFTA_HOOK_HOOKNUM] = BUILD_POLICY(U32),
[NFTA_HOOK_PRIORITY] = BUILD_POLICY(U32),
[NFTA_HOOK_DEV] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ - 1),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_chain_hook);
DEFINE_POLICY_SET(nfnl_nft_chain_hook);
static const NLType nfnl_nft_chain_types[] = {
[NFTA_CHAIN_TABLE] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_CHAIN_NAME] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_CHAIN_HOOK] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_chain_hook_type_system },
[NFTA_CHAIN_TYPE] = { .type = NETLINK_TYPE_STRING, .size = 16 },
[NFTA_CHAIN_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_chain_policies[] = {
[NFTA_CHAIN_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_CHAIN_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_CHAIN_HOOK] = BUILD_POLICY_NESTED(nfnl_nft_chain_hook),
[NFTA_CHAIN_TYPE] = BUILD_POLICY_WITH_SIZE(STRING, 16),
[NFTA_CHAIN_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_chain);
DEFINE_POLICY_SET(nfnl_nft_chain);
static const NLType nfnl_nft_expr_meta_types[] = {
[NFTA_META_DREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_META_KEY] = { .type = NETLINK_TYPE_U32 },
[NFTA_META_SREG] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_expr_meta_policies[] = {
[NFTA_META_DREG] = BUILD_POLICY(U32),
[NFTA_META_KEY] = BUILD_POLICY(U32),
[NFTA_META_SREG] = BUILD_POLICY(U32),
};
static const NLType nfnl_nft_expr_payload_types[] = {
[NFTA_PAYLOAD_DREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_PAYLOAD_BASE] = { .type = NETLINK_TYPE_U32 },
[NFTA_PAYLOAD_OFFSET] = { .type = NETLINK_TYPE_U32 },
[NFTA_PAYLOAD_LEN] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_expr_payload_policies[] = {
[NFTA_PAYLOAD_DREG] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_BASE] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_OFFSET] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_LEN] = BUILD_POLICY(U32),
};
static const NLType nfnl_nft_expr_nat_types[] = {
[NFTA_NAT_TYPE] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_FAMILY] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_REG_ADDR_MIN] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_REG_ADDR_MAX] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_REG_PROTO_MIN] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_REG_PROTO_MAX] = { .type = NETLINK_TYPE_U32 },
[NFTA_NAT_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_expr_nat_policies[] = {
[NFTA_NAT_TYPE] = BUILD_POLICY(U32),
[NFTA_NAT_FAMILY] = BUILD_POLICY(U32),
[NFTA_NAT_REG_ADDR_MIN] = BUILD_POLICY(U32),
[NFTA_NAT_REG_ADDR_MAX] = BUILD_POLICY(U32),
[NFTA_NAT_REG_PROTO_MIN] = BUILD_POLICY(U32),
[NFTA_NAT_REG_PROTO_MAX] = BUILD_POLICY(U32),
[NFTA_NAT_FLAGS] = BUILD_POLICY(U32),
};
static const NLType nfnl_nft_data_types[] = {
static const NLAPolicy nfnl_nft_data_policies[] = {
[NFTA_DATA_VALUE] = { .type = NETLINK_TYPE_BINARY },
};
DEFINE_TYPE_SYSTEM(nfnl_nft_data);
DEFINE_POLICY_SET(nfnl_nft_data);
static const NLType nfnl_nft_expr_bitwise_types[] = {
[NFTA_BITWISE_SREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_BITWISE_DREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_BITWISE_LEN] = { .type = NETLINK_TYPE_U32 },
[NFTA_BITWISE_MASK] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_data_type_system },
[NFTA_BITWISE_XOR] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_data_type_system },
static const NLAPolicy nfnl_nft_expr_bitwise_policies[] = {
[NFTA_BITWISE_SREG] = BUILD_POLICY(U32),
[NFTA_BITWISE_DREG] = BUILD_POLICY(U32),
[NFTA_BITWISE_LEN] = BUILD_POLICY(U32),
[NFTA_BITWISE_MASK] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_BITWISE_XOR] = BUILD_POLICY_NESTED(nfnl_nft_data),
};
static const NLType nfnl_nft_expr_cmp_types[] = {
[NFTA_CMP_SREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_CMP_OP] = { .type = NETLINK_TYPE_U32 },
[NFTA_CMP_DATA] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_data_type_system },
static const NLAPolicy nfnl_nft_expr_cmp_policies[] = {
[NFTA_CMP_SREG] = BUILD_POLICY(U32),
[NFTA_CMP_OP] = BUILD_POLICY(U32),
[NFTA_CMP_DATA] = BUILD_POLICY_NESTED(nfnl_nft_data),
};
static const NLType nfnl_nft_expr_fib_types[] = {
[NFTA_FIB_DREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_FIB_RESULT] = { .type = NETLINK_TYPE_U32 },
[NFTA_FIB_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_expr_fib_policies[] = {
[NFTA_FIB_DREG] = BUILD_POLICY(U32),
[NFTA_FIB_RESULT] = BUILD_POLICY(U32),
[NFTA_FIB_FLAGS] = BUILD_POLICY(U32),
};
static const NLType nfnl_nft_expr_lookup_types[] = {
static const NLAPolicy nfnl_nft_expr_lookup_policies[] = {
[NFTA_LOOKUP_SET] = { .type = NETLINK_TYPE_STRING },
[NFTA_LOOKUP_SREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_LOOKUP_DREG] = { .type = NETLINK_TYPE_U32 },
[NFTA_LOOKUP_FLAGS] = { .type = NETLINK_TYPE_U32 },
[NFTA_LOOKUP_SREG] = BUILD_POLICY(U32),
[NFTA_LOOKUP_DREG] = BUILD_POLICY(U32),
[NFTA_LOOKUP_FLAGS] = BUILD_POLICY(U32),
};
static const NLType nfnl_nft_expr_masq_types[] = {
[NFTA_MASQ_FLAGS] = { .type = NETLINK_TYPE_U32 },
[NFTA_MASQ_REG_PROTO_MIN] = { .type = NETLINK_TYPE_U32 },
[NFTA_MASQ_REG_PROTO_MAX] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_expr_masq_policies[] = {
[NFTA_MASQ_FLAGS] = BUILD_POLICY(U32),
[NFTA_MASQ_REG_PROTO_MIN] = BUILD_POLICY(U32),
[NFTA_MASQ_REG_PROTO_MAX] = BUILD_POLICY(U32),
};
static const NLTypeSystemUnionElement nfnl_expr_data_type_systems[] = {
{ .name = "bitwise", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_bitwise), },
{ .name = "cmp", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_cmp), },
{ .name = "fib", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_fib), },
{ .name = "lookup", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_lookup), },
{ .name = "masq", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_masq), },
{ .name = "meta", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_meta), },
{ .name = "nat", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_nat), },
{ .name = "payload", .type_system = TYPE_SYSTEM_FROM_TYPE(nfnl_nft_expr_payload), },
static const NLAPolicySetUnionElement nfnl_expr_data_policy_set_union_elements[] = {
BUILD_UNION_ELEMENT_BY_STRING("bitwise", nfnl_nft_expr_bitwise),
BUILD_UNION_ELEMENT_BY_STRING("cmp", nfnl_nft_expr_cmp),
BUILD_UNION_ELEMENT_BY_STRING("fib", nfnl_nft_expr_fib),
BUILD_UNION_ELEMENT_BY_STRING("lookup", nfnl_nft_expr_lookup),
BUILD_UNION_ELEMENT_BY_STRING("masq", nfnl_nft_expr_masq),
BUILD_UNION_ELEMENT_BY_STRING("meta", nfnl_nft_expr_meta),
BUILD_UNION_ELEMENT_BY_STRING("nat", nfnl_nft_expr_nat),
BUILD_UNION_ELEMENT_BY_STRING("payload", nfnl_nft_expr_payload),
};
DEFINE_TYPE_SYSTEM_UNION_MATCH_SIBLING(nfnl_expr_data, NFTA_EXPR_NAME);
DEFINE_POLICY_SET_UNION(nfnl_expr_data, NFTA_EXPR_NAME);
static const NLType nfnl_nft_rule_expr_types[] = {
[NFTA_EXPR_NAME] = { .type = NETLINK_TYPE_STRING, .size = 16 },
[NFTA_EXPR_DATA] = { .type = NETLINK_TYPE_UNION, .type_system_union = &nfnl_expr_data_type_system_union },
static const NLAPolicy nfnl_nft_rule_expr_policies[] = {
[NFTA_EXPR_NAME] = BUILD_POLICY_WITH_SIZE(STRING, 16),
[NFTA_EXPR_DATA] = BUILD_POLICY_NESTED_UNION_BY_STRING(nfnl_expr_data),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_rule_expr);
DEFINE_POLICY_SET(nfnl_nft_rule_expr);
static const NLType nfnl_nft_rule_types[] = {
[NFTA_RULE_TABLE] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_RULE_CHAIN] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_RULE_EXPRESSIONS] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_rule_expr_type_system }
static const NLAPolicy nfnl_nft_rule_policies[] = {
[NFTA_RULE_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_RULE_CHAIN] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_RULE_EXPRESSIONS] = BUILD_POLICY_NESTED(nfnl_nft_rule_expr),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_rule);
DEFINE_POLICY_SET(nfnl_nft_rule);
static const NLType nfnl_nft_set_types[] = {
[NFTA_SET_TABLE] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_SET_NAME] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_SET_FLAGS] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_KEY_TYPE] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_KEY_LEN] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_DATA_TYPE] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_DATA_LEN] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_POLICY] = { .type = NETLINK_TYPE_U32 },
[NFTA_SET_ID] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_set_policies[] = {
[NFTA_SET_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_FLAGS] = BUILD_POLICY(U32),
[NFTA_SET_KEY_TYPE] = BUILD_POLICY(U32),
[NFTA_SET_KEY_LEN] = BUILD_POLICY(U32),
[NFTA_SET_DATA_TYPE] = BUILD_POLICY(U32),
[NFTA_SET_DATA_LEN] = BUILD_POLICY(U32),
[NFTA_SET_POLICY] = BUILD_POLICY(U32),
[NFTA_SET_ID] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_set);
DEFINE_POLICY_SET(nfnl_nft_set);
static const NLType nfnl_nft_setelem_types[] = {
[NFTA_SET_ELEM_KEY] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_data_type_system },
[NFTA_SET_ELEM_DATA] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_data_type_system },
[NFTA_SET_ELEM_FLAGS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy nfnl_nft_setelem_policies[] = {
[NFTA_SET_ELEM_KEY] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_SET_ELEM_DATA] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_SET_ELEM_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_setelem);
DEFINE_POLICY_SET(nfnl_nft_setelem);
static const NLType nfnl_nft_setelem_list_types[] = {
[NFTA_SET_ELEM_LIST_TABLE] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_SET_ELEM_LIST_SET] = { .type = NETLINK_TYPE_STRING, .size = NFT_TABLE_MAXNAMELEN - 1 },
[NFTA_SET_ELEM_LIST_ELEMENTS] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_setelem_type_system },
static const NLAPolicy nfnl_nft_setelem_list_policies[] = {
[NFTA_SET_ELEM_LIST_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_ELEM_LIST_SET] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_ELEM_LIST_ELEMENTS] = BUILD_POLICY_NESTED(nfnl_nft_setelem),
};
DEFINE_TYPE_SYSTEM(nfnl_nft_setelem_list);
DEFINE_POLICY_SET(nfnl_nft_setelem_list);
static const NLType nfnl_subsys_nft_types [] = {
[NFT_MSG_DELTABLE] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_table_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_NEWTABLE] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_table_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_NEWCHAIN] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_chain_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_NEWRULE] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_rule_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_NEWSET] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_set_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_NEWSETELEM] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_setelem_list_type_system, .size = sizeof(struct nfgenmsg) },
[NFT_MSG_DELSETELEM] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_nft_setelem_list_type_system, .size = sizeof(struct nfgenmsg) },
static const NLAPolicy nfnl_subsys_nft_policies[] = {
[NFT_MSG_DELTABLE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_table, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWTABLE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_table, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWCHAIN] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_chain, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWRULE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_rule, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWSET] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_set, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWSETELEM] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_setelem_list, sizeof(struct nfgenmsg)),
[NFT_MSG_DELSETELEM] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_setelem_list, sizeof(struct nfgenmsg)),
};
DEFINE_TYPE_SYSTEM(nfnl_subsys_nft);
DEFINE_POLICY_SET(nfnl_subsys_nft);
static const NLType nfnl_msg_batch_types [] = {
[NFNL_BATCH_GENID] = { .type = NETLINK_TYPE_U32 }
static const NLAPolicy nfnl_msg_batch_policies[] = {
[NFNL_BATCH_GENID] = BUILD_POLICY(U32)
};
DEFINE_TYPE_SYSTEM(nfnl_msg_batch);
DEFINE_POLICY_SET(nfnl_msg_batch);
static const NLType nfnl_subsys_none_types[] = {
[NFNL_MSG_BATCH_BEGIN] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_msg_batch_type_system, .size = sizeof(struct nfgenmsg) },
[NFNL_MSG_BATCH_END] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_msg_batch_type_system, .size = sizeof(struct nfgenmsg) },
static const NLAPolicy nfnl_subsys_none_policies[] = {
[NFNL_MSG_BATCH_BEGIN] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_msg_batch, sizeof(struct nfgenmsg)),
[NFNL_MSG_BATCH_END] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_msg_batch, sizeof(struct nfgenmsg)),
};
DEFINE_TYPE_SYSTEM(nfnl_subsys_none);
DEFINE_POLICY_SET(nfnl_subsys_none);
static const NLType nfnl_types[] = {
[NFNL_SUBSYS_NONE] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_subsys_none_type_system },
[NFNL_SUBSYS_NFTABLES] = { .type = NETLINK_TYPE_NESTED, .type_system = &nfnl_subsys_nft_type_system },
static const NLAPolicy nfnl_policies[] = {
[NFNL_SUBSYS_NONE] = BUILD_POLICY_NESTED(nfnl_subsys_none),
[NFNL_SUBSYS_NFTABLES] = BUILD_POLICY_NESTED(nfnl_subsys_nft),
};
DEFINE_TYPE_SYSTEM(nfnl);
DEFINE_POLICY_SET(nfnl);
const NLType *nfnl_get_type(uint16_t nlmsg_type) {
const NLTypeSystem *subsys;
const NLAPolicy *nfnl_get_policy(uint16_t nlmsg_type) {
const NLAPolicySet *subsys;
subsys = type_system_get_type_system(&nfnl_type_system, nlmsg_type >> 8);
subsys = policy_set_get_policy_set(&nfnl_policy_set, NFNL_SUBSYS_ID(nlmsg_type));
if (!subsys)
return NULL;
return type_system_get_type(subsys, nlmsg_type & ((1U << 8) - 1));
return policy_set_get_policy(subsys, NFNL_MSG_TYPE(nlmsg_type));
}
src/libsystemd/sd-netlink/netlink-types-rtnl.c
+912 -916
View File
File diff suppressed because it is too large Load Diff
src/libsystemd/sd-netlink/netlink-types.c
+71 -80
View File
@@ -6,157 +6,148 @@
#include "netlink-internal.h"
#include "netlink-types-internal.h"
static const NLType empty_types[1] = {
static const NLAPolicy empty_policies[1] = {
/* fake array to avoid .types==NULL, which denotes invalid type-systems */
};
DEFINE_TYPE_SYSTEM(empty);
DEFINE_POLICY_SET(empty);
static const NLType error_types[] = {
[NLMSGERR_ATTR_MSG] = { .type = NETLINK_TYPE_STRING },
[NLMSGERR_ATTR_OFFS] = { .type = NETLINK_TYPE_U32 },
static const NLAPolicy error_policies[] = {
[NLMSGERR_ATTR_MSG] = BUILD_POLICY(STRING),
[NLMSGERR_ATTR_OFFS] = BUILD_POLICY(U32),
};
DEFINE_TYPE_SYSTEM(error);
DEFINE_POLICY_SET(error);
static const NLType basic_types[] = {
[NLMSG_DONE] = { .type = NETLINK_TYPE_NESTED, .type_system = &empty_type_system },
[NLMSG_ERROR] = { .type = NETLINK_TYPE_NESTED, .type_system = &error_type_system, .size = sizeof(struct nlmsgerr) },
static const NLAPolicy basic_policies[] = {
[NLMSG_DONE] = BUILD_POLICY_NESTED(empty),
[NLMSG_ERROR] = BUILD_POLICY_NESTED_WITH_SIZE(error, sizeof(struct nlmsgerr)),
};
DEFINE_TYPE_SYSTEM(basic);
DEFINE_POLICY_SET(basic);
uint16_t type_get_type(const NLType *type) {
assert(type);
return type->type;
NLAType policy_get_type(const NLAPolicy *policy) {
return ASSERT_PTR(policy)->type;
}
size_t type_get_size(const NLType *type) {
assert(type);
return type->size;
size_t policy_get_size(const NLAPolicy *policy) {
return ASSERT_PTR(policy)->size;
}
const NLTypeSystem *type_get_type_system(const NLType *nl_type) {
assert(nl_type);
assert(nl_type->type == NETLINK_TYPE_NESTED);
assert(nl_type->type_system);
return nl_type->type_system;
const NLAPolicySet *policy_get_policy_set(const NLAPolicy *policy) {
assert(policy);
assert(policy->type == NETLINK_TYPE_NESTED);
return ASSERT_PTR(policy->policy_set);
}
const NLTypeSystemUnion *type_get_type_system_union(const NLType *nl_type) {
assert(nl_type);
assert(nl_type->type == NETLINK_TYPE_UNION);
assert(nl_type->type_system_union);
return nl_type->type_system_union;
const NLAPolicySetUnion *policy_get_policy_set_union(const NLAPolicy *policy) {
assert(policy);
assert(IN_SET(policy->type, NETLINK_TYPE_NESTED_UNION_BY_STRING, NETLINK_TYPE_NESTED_UNION_BY_FAMILY));
return ASSERT_PTR(policy->policy_set_union);
}
int type_system_root_get_type_system_and_header_size(
int netlink_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t type,
const NLTypeSystem **ret_type_system,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size) {
const NLType *nl_type;
const NLAPolicy *policy;
assert(nl);
if (IN_SET(type, NLMSG_DONE, NLMSG_ERROR))
nl_type = type_system_get_type(&basic_type_system, type);
policy = policy_set_get_policy(&basic_policy_set, type);
else
switch (nl->protocol) {
case NETLINK_ROUTE:
nl_type = rtnl_get_type(type);
policy = rtnl_get_policy(type);
break;
case NETLINK_NETFILTER:
nl_type = nfnl_get_type(type);
policy = nfnl_get_policy(type);
break;
case NETLINK_GENERIC:
return genl_get_type_system_and_header_size(nl, type, ret_type_system, ret_header_size);
return genl_get_policy_set_and_header_size(nl, type, ret_policy_set, ret_header_size);
default:
return -EOPNOTSUPP;
}
if (!nl_type)
if (!policy)
return -EOPNOTSUPP;
if (type_get_type(nl_type) != NETLINK_TYPE_NESTED)
if (policy_get_type(policy) != NETLINK_TYPE_NESTED)
return -EOPNOTSUPP;
if (ret_type_system)
*ret_type_system = type_get_type_system(nl_type);
if (ret_policy_set)
*ret_policy_set = policy_get_policy_set(policy);
if (ret_header_size)
*ret_header_size = type_get_size(nl_type);
*ret_header_size = policy_get_size(policy);
return 0;
}
const NLType *type_system_get_type(const NLTypeSystem *type_system, uint16_t type) {
const NLType *nl_type;
const NLAPolicy *policy_set_get_policy(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
assert(type_system);
assert(type_system->types);
assert(policy_set);
assert(policy_set->policies);
if (type >= type_system->count)
if (attr_type >= policy_set->count)
return NULL;
nl_type = &type_system->types[type];
policy = &policy_set->policies[attr_type];
if (nl_type->type == NETLINK_TYPE_UNSPEC)
if (policy->type == NETLINK_TYPE_UNSPEC)
return NULL;
return nl_type;
return policy;
}
const NLTypeSystem *type_system_get_type_system(const NLTypeSystem *type_system, uint16_t type) {
const NLType *nl_type;
const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
nl_type = type_system_get_type(type_system, type);
if (!nl_type)
policy = policy_set_get_policy(policy_set, attr_type);
if (!policy)
return NULL;
return type_get_type_system(nl_type);
return policy_get_policy_set(policy);
}
const NLTypeSystemUnion *type_system_get_type_system_union(const NLTypeSystem *type_system, uint16_t type) {
const NLType *nl_type;
const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
nl_type = type_system_get_type(type_system, type);
if (!nl_type)
policy = policy_set_get_policy(policy_set, attr_type);
if (!policy)
return NULL;
return type_get_type_system_union(nl_type);
return policy_get_policy_set_union(policy);
}
NLMatchType type_system_union_get_match_type(const NLTypeSystemUnion *type_system_union) {
assert(type_system_union);
return type_system_union->match_type;
uint16_t policy_set_union_get_match_attribute(const NLAPolicySetUnion *policy_set_union) {
assert(policy_set_union->match_attribute != 0);
return policy_set_union->match_attribute;
}
uint16_t type_system_union_get_match_attribute(const NLTypeSystemUnion *type_system_union) {
assert(type_system_union);
assert(type_system_union->match_type == NL_MATCH_SIBLING);
return type_system_union->match_attribute;
}
const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *policy_set_union, const char *string) {
assert(policy_set_union);
assert(policy_set_union->elements);
assert(string);
const NLTypeSystem *type_system_union_get_type_system_by_string(const NLTypeSystemUnion *type_system_union, const char *key) {
assert(type_system_union);
assert(type_system_union->elements);
assert(type_system_union->match_type == NL_MATCH_SIBLING);
assert(key);
for (size_t i = 0; i < type_system_union->count; i++)
if (streq(type_system_union->elements[i].name, key))
return &type_system_union->elements[i].type_system;
for (size_t i = 0; i < policy_set_union->count; i++)
if (streq(policy_set_union->elements[i].string, string))
return &policy_set_union->elements[i].policy_set;
return NULL;
}
const NLTypeSystem *type_system_union_get_type_system_by_protocol(const NLTypeSystemUnion *type_system_union, uint16_t protocol) {
assert(type_system_union);
assert(type_system_union->elements);
assert(type_system_union->match_type == NL_MATCH_PROTOCOL);
const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *policy_set_union, int family) {
assert(policy_set_union);
assert(policy_set_union->elements);
for (size_t i = 0; i < type_system_union->count; i++)
if (type_system_union->elements[i].protocol == protocol)
return &type_system_union->elements[i].type_system;
for (size_t i = 0; i < policy_set_union->count; i++)
if (policy_set_union->elements[i].family == family)
return &policy_set_union->elements[i].policy_set;
return NULL;
}
src/libsystemd/sd-netlink/netlink-types.h
+34 -35
View File
@@ -1,10 +1,14 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include "sd-netlink.h"
enum {
NETLINK_TYPE_UNSPEC,
typedef enum NLAType {
NETLINK_TYPE_UNSPEC, /* NLA_UNSPEC */
NETLINK_TYPE_BINARY, /* NLA_BINARY */
NETLINK_TYPE_FLAG, /* NLA_FLAG */
NETLINK_TYPE_U8, /* NLA_U8 */
NETLINK_TYPE_U16, /* NLA_U16 */
NETLINK_TYPE_U32, /* NLA_U32 */
@@ -14,51 +18,46 @@ enum {
NETLINK_TYPE_S32, /* NLA_S32 */
NETLINK_TYPE_S64, /* NLA_S64 */
NETLINK_TYPE_STRING, /* NLA_STRING */
NETLINK_TYPE_FLAG, /* NLA_FLAG */
NETLINK_TYPE_BITFIELD32, /* NLA_BITFIELD32 */
NETLINK_TYPE_REJECT, /* NLA_REJECT */
NETLINK_TYPE_IN_ADDR,
NETLINK_TYPE_ETHER_ADDR,
NETLINK_TYPE_CACHE_INFO,
NETLINK_TYPE_NESTED, /* NLA_NESTED */
NETLINK_TYPE_UNION,
NETLINK_TYPE_SOCKADDR,
NETLINK_TYPE_BINARY,
NETLINK_TYPE_BITFIELD32, /* NLA_BITFIELD32 */
NETLINK_TYPE_REJECT, /* NLA_REJECT */
};
NETLINK_TYPE_NESTED, /* NLA_NESTED */
NETLINK_TYPE_NESTED_UNION_BY_STRING,
NETLINK_TYPE_NESTED_UNION_BY_FAMILY,
_NETLINK_TYPE_MAX,
_NETLINK_TYPE_INVALID = -EINVAL,
} NLAType;
typedef enum NLMatchType {
NL_MATCH_SIBLING,
NL_MATCH_PROTOCOL,
} NLMatchType;
typedef struct NLAPolicy NLAPolicy;
typedef struct NLAPolicySet NLAPolicySet;
typedef struct NLAPolicySetUnion NLAPolicySetUnion;
typedef struct NLTypeSystemUnion NLTypeSystemUnion;
typedef struct NLTypeSystem NLTypeSystem;
typedef struct NLType NLType;
const NLType *rtnl_get_type(uint16_t nlmsg_type);
const NLType *nfnl_get_type(uint16_t nlmsg_type);
const NLTypeSystem *genl_get_type_system_by_name(const char *name);
int genl_get_type_system_and_header_size(
const NLAPolicy *rtnl_get_policy(uint16_t nlmsg_type);
const NLAPolicy *nfnl_get_policy(uint16_t nlmsg_type);
const NLAPolicySet *genl_get_policy_set_by_name(const char *name);
int genl_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t id,
const NLTypeSystem **ret_type_system,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size);
uint16_t type_get_type(const NLType *type);
size_t type_get_size(const NLType *type);
const NLTypeSystem *type_get_type_system(const NLType *type);
const NLTypeSystemUnion *type_get_type_system_union(const NLType *type);
NLAType policy_get_type(const NLAPolicy *policy);
size_t policy_get_size(const NLAPolicy *policy);
const NLAPolicySet *policy_get_policy_set(const NLAPolicy *policy);
const NLAPolicySetUnion *policy_get_policy_set_union(const NLAPolicy *policy);
int type_system_root_get_type_system_and_header_size(
int netlink_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t type,
const NLTypeSystem **ret_type_system,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size);
const NLType *type_system_get_type(const NLTypeSystem *type_system, uint16_t type);
const NLTypeSystem *type_system_get_type_system(const NLTypeSystem *type_system, uint16_t type);
const NLTypeSystemUnion *type_system_get_type_system_union(const NLTypeSystem *type_system, uint16_t type);
NLMatchType type_system_union_get_match_type(const NLTypeSystemUnion *type_system_union);
uint16_t type_system_union_get_match_attribute(const NLTypeSystemUnion *type_system_union);
const NLTypeSystem *type_system_union_get_type_system_by_string(const NLTypeSystemUnion *type_system_union, const char *key);
const NLTypeSystem *type_system_union_get_type_system_by_protocol(const NLTypeSystemUnion *type_system_union, uint16_t protocol);
const NLAPolicy *policy_set_get_policy(const NLAPolicySet *policy_set, uint16_t attr_type);
const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *type_system, uint16_t attr_type);
const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *type_system, uint16_t attr_type);
uint16_t policy_set_union_get_match_attribute(const NLAPolicySetUnion *policy_set_union);
const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *type_system_union, const char *string);
const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *type_system_union, int family);
src/systemd/sd-netlink.h
+38 -38
View File
@@ -71,51 +71,51 @@ int sd_netlink_detach_event(sd_netlink *nl);
int sd_netlink_attach_filter(sd_netlink *nl, size_t len, struct sock_filter *filter);
/* message */
int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data);
int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, char * const *data);
int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type);
int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data);
int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data);
int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data);
int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, uint64_t data);
int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int8_t data);
int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, int16_t data);
int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, int32_t data);
int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, int64_t data);
int sd_netlink_message_append_data(sd_netlink_message *m, unsigned short type, const void *data, size_t len);
int sd_netlink_message_append_string(sd_netlink_message *m, uint16_t attr_type, const char *data);
int sd_netlink_message_append_strv(sd_netlink_message *m, uint16_t attr_type, char * const *data);
int sd_netlink_message_append_flag(sd_netlink_message *m, uint16_t attr_type);
int sd_netlink_message_append_u8(sd_netlink_message *m, uint16_t attr_type, uint8_t data);
int sd_netlink_message_append_u16(sd_netlink_message *m, uint16_t attr_type, uint16_t data);
int sd_netlink_message_append_u32(sd_netlink_message *m, uint16_t attr_type, uint32_t data);
int sd_netlink_message_append_u64(sd_netlink_message *m, uint16_t attr_type, uint64_t data);
int sd_netlink_message_append_s8(sd_netlink_message *m, uint16_t attr_type, int8_t data);
int sd_netlink_message_append_s16(sd_netlink_message *m, uint16_t attr_type, int16_t data);
int sd_netlink_message_append_s32(sd_netlink_message *m, uint16_t attr_type, int32_t data);
int sd_netlink_message_append_s64(sd_netlink_message *m, uint16_t attr_type, int64_t data);
int sd_netlink_message_append_data(sd_netlink_message *m, uint16_t attr_type, const void *data, size_t len);
int sd_netlink_message_append_container_data(
sd_netlink_message *m,
unsigned short container_type,
unsigned short type,
uint16_t container_type,
uint16_t attr_type,
const void *data,
size_t len);
int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data);
int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data);
int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, unsigned short type, const struct sockaddr_in *data);
int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, unsigned short type, const struct sockaddr_in6 *data);
int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data);
int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info);
int sd_netlink_message_append_in_addr(sd_netlink_message *m, uint16_t attr_type, const struct in_addr *data);
int sd_netlink_message_append_in6_addr(sd_netlink_message *m, uint16_t attr_type, const struct in6_addr *data);
int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, uint16_t attr_type, const struct sockaddr_in *data);
int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, uint16_t attr_type, const struct sockaddr_in6 *data);
int sd_netlink_message_append_ether_addr(sd_netlink_message *m, uint16_t attr_type, const struct ether_addr *data);
int sd_netlink_message_append_cache_info(sd_netlink_message *m, uint16_t attr_type, const struct ifa_cacheinfo *info);
int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type);
int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key);
int sd_netlink_message_open_container(sd_netlink_message *m, uint16_t attr_type);
int sd_netlink_message_open_container_union(sd_netlink_message *m, uint16_t attr_type, const char *key);
int sd_netlink_message_close_container(sd_netlink_message *m);
int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t size, void *data);
int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data);
int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data);
int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short type, char **data);
int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data);
int sd_netlink_message_read_strv(sd_netlink_message *m, unsigned short container_type, unsigned short type_id, char ***ret);
int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data);
int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data);
int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data);
int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data);
int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info);
int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data);
int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data);
int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type);
int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type);
int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type);
int sd_netlink_message_read(sd_netlink_message *m, uint16_t attr_type, size_t size, void *data);
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_data_suffix0(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_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_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_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);
int sd_netlink_message_exit_container(sd_netlink_message *m);
int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type);