add typeof keyword
Florian Westphal
maintainerv3 cover add typeof keyword
This patch series adds the typeof keyword.
This depends on Pablos extensions to libnftnls udata parsing facilities.
named set can be configured as follows:
set os {
typeof osf name
elements = { "Linux", "Windows" }
}
The type is stored in the kernel via the udata infrastructure. On listing -- if a udata type is present -- nft will validate that this type matches the set key length and, if so, will print back the 'typeof' information.
Note that while 'typeof' can be used with concatenations, they only work as aliases for known types -- its currently not possible to use integer/string types via the 'typeof' keyword (its rejected at evaluation stage due to 0-length sub expression types).
Doing so requires a bit more work to dissect the correct key geometry on netlink dumps.
In case typeof udata is not there/invalid, the normal 'type' syntax is used.
This patch set isn't complete -- the test cases will not work yet because 'meta' and 'osf' lack the udata parse/buil callbacks.
This is caught at the parsing stage.
The following changes since commit ddbe652bf0f4ed300bae9497250130d68e4cbf5b:
py: load the SONAME-versioned shared object (2019-12-10 19:07:16 +0100)
are available in the Git repository at:
git://git.breakpoint.cc/fw/nftables.git typeof_rework_09
for you to fetch changes up to 02485d775dea55a067c6dbea0826ab3fc9ff7398:
tests: add typeof test cases (2019-12-17 12:19:51 +0100)
----------------------------------------------------------------
Florian Westphal (7):
parser: add a helper for concat expression handling
src: store expr, not dtype to track data in sets
src: add "typeof" build/parse/print support
mnl: round up the map data size too
evaluate: print a hint about 'typeof' syntax on 0 keylen
doc: mention 'typeof' as alternative to 'type' keyword
tests: add typeof test cases
Pablo Neira Ayuso (3):
proto: add proto_desc_id enumeration
expr: add expr_ops_by_type()
parser: add typeof keyword for declarations
doc/nft.txt | 12 +- include/datatype.h | 1 - include/expression.h | 5 + include/netlink.h | 1 - include/proto.h | 27 ++++ include/rule.h | 7 +- src/datatype.c | 5 - src/evaluate.c | 81 +++++++---- src/expression.c | 14 +- src/json.c | 4 +- src/mnl.c | 30 ++++- src/monitor.c | 2 +- src/netlink.c | 149 +++++++++++++++++---- src/parser_bison.y | 148 +++++++++++--------- src/parser_json.c | 8 +- src/payload.c | 75 +++++++++++ src/proto.c | 46 +++++++ src/rule.c | 48 +++++-- src/scanner.l | 1 + src/segtree.c | 8 +- tests/shell/testcases/maps/dumps/typeof_maps_0.nft | 16 +++ tests/shell/testcases/maps/typeof_maps_0 | 27 ++++ tests/shell/testcases/sets/dumps/typeof_sets_0.nft | 19 +++ tests/shell/testcases/sets/typeof_sets_0 | 29 ++++ 24 files changed, 621 insertions(+), 142 deletions(-) create mode 100644 tests/shell/testcases/maps/dumps/typeof_maps_0.nft create mode 100755 tests/shell/testcases/maps/typeof_maps_0 create mode 100644 tests/shell/testcases/sets/dumps/typeof_sets_0.nft create mode 100755 tests/shell/testcases/sets/typeof_sets_0
Florian Westphal
maintainerPATCH v3 1/10 parser: add a helper for concat expression handling
Cull the repeated copy&paste snippets and add/use a helper for this.
--- src/parser_bison.y | 99 ++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 56 deletions(-)
src/parser_bison.y +43 -56
@@ -102,6 +102,25 @@ static void location_update(struct location *loc, struct location *rhs, int n) } } +static struct expr *handle_concat_expr(const struct location *loc, + struct expr *expr, + struct expr *expr_l, struct expr *expr_r, + struct location loc_rhs[3]) +{ + if (expr->etype != EXPR_CONCAT) { + expr = concat_expr_alloc(loc); + compound_expr_add(expr, expr_l); + } else { + location_update(&expr_r->location, loc_rhs, 2); + + expr = expr_l; + expr->location = *loc; + } + + compound_expr_add(expr, expr_r); + return expr; +} + #define YYLLOC_DEFAULT(Current, Rhs, N) location_update(&Current, Rhs, N) #define symbol_value(loc, str) \
@@ -1878,20 +1897,12 @@ data_type_atom_expr : type_identifier data_type_expr : data_type_atom_expr | data_type_expr DOT data_type_atom_expr { - if ($1->etype != EXPR_CONCAT) { - $$ = concat_expr_alloc(&@$); - compound_expr_add($$, $1); - } else { - struct location rhs[] = { - [1] = @2, - [2] = @3, - }; - location_update(&$3->location, rhs, 2); - - $$ = $1; - $$->location = @$; - } - compound_expr_add($$, $3); + struct location rhs[] = { + [1] = @2, + [2] = @3, + }; + + $$ = handle_concat_expr(&@$, $$, $1, $3, rhs); } ;
@@ -2992,20 +3003,12 @@ basic_stmt_expr : inclusive_or_stmt_expr concat_stmt_expr : basic_stmt_expr | concat_stmt_expr DOT primary_stmt_expr { - if ($$->etype != EXPR_CONCAT) { - $$ = concat_expr_alloc(&@$); - compound_expr_add($$, $1); - } else { - struct location rhs[] = { - [1] = @2, - [2] = @3, - }; - location_update(&$3->location, rhs, 2); - - $$ = $1; - $$->location = @$; - } - compound_expr_add($$, $3); + struct location rhs[] = { + [1] = @2, + [2] = @3, + }; + + $$ = handle_concat_expr(&@$, $$, $1, $3, rhs); } ;
@@ -3525,20 +3528,12 @@ basic_expr : inclusive_or_expr concat_expr : basic_expr | concat_expr DOT basic_expr { - if ($$->etype != EXPR_CONCAT) { - $$ = concat_expr_alloc(&@$); - compound_expr_add($$, $1); - } else { - struct location rhs[] = { - [1] = @2, - [2] = @3, - }; - location_update(&$3->location, rhs, 2); - - $$ = $1; - $$->location = @$; - } - compound_expr_add($$, $3); + struct location rhs[] = { + [1] = @2, + [2] = @3, + }; + + $$ = handle_concat_expr(&@$, $$, $1, $3, rhs); } ;
@@ -3946,20 +3941,12 @@ basic_rhs_expr : inclusive_or_rhs_expr concat_rhs_expr : basic_rhs_expr | concat_rhs_expr DOT basic_rhs_expr { - if ($$->etype != EXPR_CONCAT) { - $$ = concat_expr_alloc(&@$); - compound_expr_add($$, $1); - } else { - struct location rhs[] = { - [1] = @2, - [2] = @3, - }; - location_update(&$3->location, rhs, 2); - - $$ = $1; - $$->location = @$; - } - compound_expr_add($$, $3); + struct location rhs[] = { + [1] = @2, + [2] = @3, + }; + + $$ = handle_concat_expr(&@$, $$, $1, $3, rhs); } ;
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 2/10 src: store expr, not dtype to track data in sets
In reply to Florian WestphalThis will be needed once we add support for the 'typeof' keyword to handle maps that could e.g. store 'ct helper' "type" values.
Instead of:
set foo {
type ipv4_addr . mark;this would allow
set foo {
typeof(ip saddr) . typeof(ct mark);(exact syntax TBD).
This would be needed to allow sets that store variable-sized data types (string, integer and the like) that can't be used at at the moment.
Adding special data types for everything is problematic due to the large amount of different types needed.
For anonymous sets, e.g. "string" can be used because the needed size can be inferred from the statement, e.g. 'osf name { "Windows", "Linux }', but in case of named sets that won't work because 'type string' lacks the context needed to derive the size information.
With 'typeof(osf name)' the context is there, but at the moment it won't help because the expression is discarded instantly and only the data type is retained.
--- include/datatype.h | 1 - include/netlink.h | 1 - include/rule.h | 6 ++--- src/datatype.c | 5 ---- src/evaluate.c | 58 ++++++++++++++++++++++++++++++++-------------- src/expression.c | 2 +- src/json.c | 4 ++-- src/mnl.c | 6 ++--- src/monitor.c | 2 +- src/netlink.c | 32 ++++++++++++------------- src/parser_bison.y | 3 +-- src/parser_json.c | 8 +++++-- src/rule.c | 8 +++---- src/segtree.c | 8 +++++-- 14 files changed, 81 insertions(+), 63 deletions(-)
include/datatype.h +0 -1
@@ -293,7 +293,6 @@ concat_subtype_lookup(uint32_t type, unsigned int n)extern const struct datatype *set_datatype_alloc (const struct datatype *orig_dtype,unsigned int byteorder); -extern void set_datatype_destroy (const struct datatype *dtype);extern void time_print (uint64_t msec,struct output_ctx *octx); extern struct error_record *time_parse(const struct location *loc,
include/netlink.h +0 -1
@@ -189,6 +189,5 @@ int netlink_events_trace_cb(const struct nlmsghdr *nlh, int type, struct netlink_mon_handler *monh);enum nft_data_types dtype_map_to_kernel (const struct datatype *dtype); -const struct datatype *dtype_map_from_kernel (enum nft_data_types type);#endif /* NFTABLES_NETLINK_H */
include/rule.h +2 -4
@@ -283,8 +283,7 @@ extern struct rule *rule_lookup_by_index(const struct chain *chain,* @gc_int: garbage collection interval * @timeout: default timeout value * @key: key expression (data type, length)) -* @datatype: mapping data type -* @datalen: mapping data len +* @data: mapping data expression * @objtype: mapping object type * @init: initializer * @rg_cache: cached range element (left)
@@ -301,8 +300,7 @@ struct set {uint32_t gc_int;uint64_t timeout;struct expr *key; -const struct datatype *datatype; -unsigned int datalen; +struct expr *data;uint32_t objtype;struct expr *init;struct expr *rg_cache;
src/datatype.c +0 -5
@@ -1190,11 +1190,6 @@ const struct datatype *set_datatype_alloc(const struct datatype *orig_dtype,return dtype; } -void set_datatype_destroy (const struct datatype *dtype) -{ -datatype_free (dtype); -} -static struct error_record *time_unit_parse (const struct location *loc,const char *str,uint64_t *unit) {
src/evaluate.c +40 -18
118 lines not on this page · raw message
src/expression.c +1 -1
@@ -1010,7 +1010,7 @@ static void map_expr_print(const struct expr *expr, struct output_ctx *octx) {expr_print (expr->map, octx);if (expr->mappings->etype ==EXPR_SET_REF && - expr->mappings->set->datatype->type ==TYPE_VERDICT ) + expr->mappings->set->data->dtype->type ==TYPE_VERDICT )nft_print (octx," vmap " );else nft_print (octx," map " );
src/json.c +2 -2
@@ -82,7 +82,7 @@ static json_t *set_print_json(struct output_ctx *octx, const struct set *set)if (set_is_datamap (set->flags)) { type ="map" ; - datatype_ext = set->datatype->name; + datatype_ext = set->data->dtype->name; }else if (set_is_objmap (set->flags)) { type ="map" ; datatype_ext =obj_type_name (set->objtype);
@@ -645,7 +645,7 @@ json_t *map_expr_json(const struct expr *expr, struct output_ctx *octx)const char *type ="map" ;if (expr->mappings->etype ==EXPR_SET_REF && - expr->mappings->set->datatype->type ==TYPE_VERDICT ) + expr->mappings->set->data->dtype->type ==TYPE_VERDICT ) type ="vmap" ; return json_pack("{s:{s:o, s:o}}", type,
src/mnl.c +3 -3
@@ -839,9 +839,9 @@ int mnl_nft_set_add(struct netlink_ctx *ctx, const struct cmd *cmd, div_round_up(set->key->len, BITS_PER_BYTE));if (set_is_datamap (set->flags)) {nftnl_set_set_u32 (nls,NFTNL_SET_DATA_TYPE , -dtype_map_to_kernel (set->datatype)); +dtype_map_to_kernel (set->data->dtype));nftnl_set_set_u32 (nls,NFTNL_SET_DATA_LEN , - set->datalen /BITS_PER_BYTE ); + set->data->len /BITS_PER_BYTE ); }if (set_is_objmap (set->flags))nftnl_set_set_u32 (nls,NFTNL_SET_OBJ_TYPE , set->objtype);
@@ -873,7 +873,7 @@ int mnl_nft_set_add(struct netlink_ctx *ctx, const struct cmd *cmd,if (set_is_datamap (set->flags) && !nftnl_udata_put_u32 (udbuf,NFTNL_UDATA_SET_DATABYTEORDER , - set->datatype->byteorder)) + set->data->byteorder))memory_allocation_error (); if (set->automerge &&
src/monitor.c +1 -1
@@ -401,7 +401,7 @@ static int netlink_events_setelem_cb(const struct nlmsghdr *nlh, int type,*/ dummyset =set_alloc (monh->loc); dummyset->key =expr_clone (set->key); - dummyset->datatype = set->datatype; + dummyset->data = set->data; dummyset->flags = set->flags; dummyset->init =set_expr_alloc (monh->loc, set);
src/netlink.c +15 -17
@@ -534,7 +534,7 @@ enum nft_data_types dtype_map_to_kernel(const struct datatype *dtype) } } -const struct datatype *dtype_map_from_kernel (enum nft_data_types type) +static const struct datatype *dtype_map_from_kernel (enum nft_data_types type) {switch (type) {case NFT_DATA_VERDICT :
@@ -581,10 +581,10 @@ struct set *netlink_delinearize_set(struct netlink_ctx *ctx, const struct nftnl_set *nls) {const struct nftnl_udata *ud[NFTNL_UDATA_SET_MAX +1 ] = {}; -uint32_t flags, key, data, data_len, objtype =0 ;enum byteorder keybyteorder =BYTEORDER_INVALID ;enum byteorder databyteorder =BYTEORDER_INVALID ; -const struct datatype *keytype, *datatype; +const struct datatype *keytype, *datatype =NULL ; +uint32_t flags, key, objtype =0 ;bool automerge = false;const char *udata;struct set *set;
@@ -618,6 +618,8 @@ struct set *netlink_delinearize_set(struct netlink_ctx *ctx, flags =nftnl_set_get_u32 (nls,NFTNL_SET_FLAGS );if (set_is_datamap (flags)) { +uint32_t data; + data =nftnl_set_get_u32 (nls,NFTNL_SET_DATA_TYPE ); datatype =dtype_map_from_kernel (data);if (datatype ==NULL ) {
@@ -626,8 +628,7 @@ struct set *netlink_delinearize_set(struct netlink_ctx *ctx, data);return NULL ; } - }else - datatype =NULL ; + }if (set_is_objmap (flags)) { objtype =nftnl_set_get_u32 (nls,NFTNL_SET_OBJ_TYPE );
@@ -650,16 +651,13 @@ struct set *netlink_delinearize_set(struct netlink_ctx *ctx, set->objtype = objtype; + set->data =NULL ;if (datatype) - set->datatype =datatype_get (set_datatype_alloc (datatype, - databyteorder)); -else - set->datatype =NULL ; - -if (nftnl_set_is_set (nls,NFTNL_SET_DATA_LEN )) { - data_len =nftnl_set_get_u32 (nls,NFTNL_SET_DATA_LEN ); - set->datalen = data_len *BITS_PER_BYTE ; - } + set->data =constant_expr_alloc (&netlink_location, +set_datatype_alloc (datatype, databyteorder), + databyteorder, +nftnl_set_get_u32 (nls,NFTNL_SET_DATA_LEN ) *BITS_PER_BYTE , +NULL );if (nftnl_set_is_set (nls,NFTNL_SET_TIMEOUT )) set->timeout =nftnl_set_get_u64 (nls,NFTNL_SET_TIMEOUT );
@@ -847,10 +845,10 @@ int netlink_delinearize_setelem(struct nftnl_set_elem *nlse, goto out; data =netlink_alloc_data (&netlink_location, &nld, - set->datatype->type ==TYPE_VERDICT ? + set->data->dtype->type ==TYPE_VERDICT ?NFT_REG_VERDICT :NFT_REG_1 ); -datatype_set (data, set->datatype); - data->byteorder = set->datatype->byteorder; +datatype_set (data, set->data->dtype); + data->byteorder = set->data->byteorder;if (data->byteorder ==BYTEORDER_HOST_ENDIAN )mpz_switch_byteorder (data->value, data->len /BITS_PER_BYTE );
src/parser_bison.y +1 -2
@@ -1749,9 +1749,8 @@ map_block : /* empty */ { $$ = $<set>-1; } stmt_separator { $1->key = $3; - $1->datatype = $5->dtype; + $1->data = $5; - expr_free($5); $1->flags |= NFT_SET_MAP; $$ = $1; }
src/parser_json.c +6 -2
@@ -2826,11 +2826,15 @@ static struct cmd *json_parse_cmd_add_set(struct json_ctx *ctx, json_t *root, }if (!json_unpack (root,"{s:s}" ,"map" , &dtype_ext)) { +const struct datatype *dtype; + set->objtype =string_to_nft_object (dtype_ext);if (set->objtype) { set->flags |=NFT_SET_OBJECT ; - }else if (datatype_lookup_byname (dtype_ext)) { - set->datatype =datatype_lookup_byname (dtype_ext); + }else if ((dtype =datatype_lookup_byname (dtype_ext))) { + set->data =constant_expr_alloc (&netlink_location, + dtype, dtype->byteorder, + dtype->size,NULL ); set->flags |=NFT_SET_MAP ; }else {json_error (ctx,"Invalid map type '%s'." , dtype_ext);
src/rule.c +4 -4
@@ -332,8 +332,8 @@ struct set *set_clone(const struct set *set) new_set->gc_int = set->gc_int; new_set->timeout = set->timeout; new_set->key =expr_clone (set->key); - new_set->datatype =datatype_get (set->datatype); - new_set->datalen = set->datalen; +if (set->data) + new_set->data =expr_clone (set->data); new_set->objtype = set->objtype; new_set->policy = set->policy; new_set->automerge = set->automerge;
@@ -356,7 +356,7 @@ void set_free(struct set *set)expr_free (set->init);handle_free (&set->handle);expr_free (set->key); -set_datatype_destroy (set->datatype); +expr_free (set->data);xfree (set); }
@@ -469,7 +469,7 @@ static void set_print_declaration(const struct set *set,nft_print (octx,"%s%stype %s" , opts->tab, opts->tab, set->key->dtype->name);if (set_is_datamap (set->flags)) -nft_print (octx," : %s" , set->datatype->name); +nft_print (octx," : %s" , set->data->dtype->name);else if (set_is_objmap (set->flags))nft_print (octx," : %s" ,obj_type_name (set->objtype));
src/segtree.c +6 -2
@@ -79,8 +79,12 @@ static void seg_tree_init(struct seg_tree *tree, const struct set *set, tree->root =RB_ROOT ; tree->keytype = set->key->dtype; tree->keylen = set->key->len; - tree->datatype = set->datatype; - tree->datalen = set->datalen; + tree->datatype =NULL ; + tree->datalen =0 ; +if (set->data) { + tree->datatype = set->data->dtype; + tree->datalen = set->data->len; + } tree->byteorder = first->byteorder; tree->debug_mask = debug_mask; }
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 3/10 proto: add proto_desc_id enumeration
In reply to Florian WestphalFrom: Pablo Neira Ayuso <[email protected]>
This allows to uniquely identify the protocol description.
--- include/proto.h | 27 +++++++++++++++++++++++++++ src/proto.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+)
include/proto.h +27 -0
@@ -63,10 +63,34 @@ struct proto_hdr_template {#define PROTO_UPPER_MAX 16#define PROTO_HDRS_MAX 20 +enum proto_desc_id { +PROTO_DESC_UNKNOWN =0 , +PROTO_DESC_AH , +PROTO_DESC_ESP , +PROTO_DESC_COMP , +PROTO_DESC_ICMP , +PROTO_DESC_IGMP , +PROTO_DESC_UDP , +PROTO_DESC_UDPLITE , +PROTO_DESC_TCP , +PROTO_DESC_DCCP , +PROTO_DESC_SCTP , +PROTO_DESC_TH , +PROTO_DESC_IP , +PROTO_DESC_IP6 , +PROTO_DESC_ICMPV6 , +PROTO_DESC_ARP , +PROTO_DESC_VLAN , +PROTO_DESC_ETHER , + __PROTO_DESC_MAX +}; +#define PROTO_DESC_MAX (__PROTO_DESC_MAX - 1) +/** * struct proto_desc - protocol header description * * @name: protocol name +* @id: protocol identifier * @base: header base * @checksum_key: key of template containing checksum * @protocol_key: key of template containing upper layer protocol description
@@ -77,6 +101,7 @@ struct proto_hdr_template {*/ struct proto_desc {const char *name; +enum proto_desc_id id;enum proto_bases base;unsigned int checksum_key;unsigned int protocol_key;
@@ -160,6 +185,8 @@ extern const struct proto_desc *proto_find_upper(const struct proto_desc *base,extern int proto_find_num (const struct proto_desc *base,const struct proto_desc *desc); +extern const struct proto_desc *proto_find_desc (enum proto_desc_id desc_id); +enum eth_hdr_fields {ETHHDR_INVALID ,ETHHDR_DADDR ,
src/proto.c +46 -0
151 lines not on this page · raw message
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 4/10 expr: add expr_ops_by_type()
In reply to Florian WestphalFrom: Pablo Neira Ayuso <[email protected]>
Fetch expression operation from the expression type.
--- include/expression.h | 1 + src/expression.c | 12 ++++++++++++ 2 files changed, 13 insertions(+)
include/expression.h +1 -0
@@ -169,6 +169,7 @@ struct expr_ops { };const struct expr_ops *expr_ops (const struct expr *e); +const struct expr_ops *expr_ops_by_type (enum expr_types etype);/** * enum expr_flags
src/expression.c +12 -0
@@ -1222,3 +1222,15 @@ const struct expr_ops *expr_ops(const struct expr *e)BUG ("Unknown expression type %d\n" , e->etype); } + +const struct expr_ops *expr_ops_by_type (enum expr_types etype) +{ +switch (etype) { +case EXPR_PAYLOAD : +return &payload_expr_ops; +default : +break ; + } + +BUG ("Unknown expression type %d\n" , etype); +}
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 5/10 parser: add typeof keyword for declarations
In reply to Florian WestphalFrom: Pablo Neira Ayuso <[email protected]>
Add a typeof keyword to automatically use the correct type in set and map declarations.
table filter {
set blacklist {
typeof ip saddr
}
chain input {
ip saddr @blacklist counter drop
}
}--- src/parser_bison.y | 46 ++++++++++++++++++++++++++++++++++++++++++++-- src/scanner.l | 1 + 2 files changed, 45 insertions(+), 2 deletions(-)
src/parser_bison.y +44 -2
@@ -223,6 +223,8 @@ int nft_lex(void *, void *, void *); %token WSCALE "wscale" %token SACKPERM "sack-perm" +%token TYPEOF "typeof" + %token HOOK "hook" %token DEVICE "device" %token DEVICES "devices"
@@ -658,8 +660,8 @@ int nft_lex(void *, void *, void *); %type <expr> symbol_expr verdict_expr integer_expr variable_expr chain_expr policy_expr %destructor { expr_free($$); } symbol_expr verdict_expr integer_expr variable_expr chain_expr policy_expr -%type <expr> primary_expr shift_expr and_expr -%destructor { expr_free($$); } primary_expr shift_expr and_expr +%type <expr> primary_expr shift_expr and_expr typeof_expr +%destructor { expr_free($$); } primary_expr shift_expr and_expr typeof_expr %type <expr> exclusive_or_expr inclusive_or_expr %destructor { expr_free($$); } exclusive_or_expr inclusive_or_expr %type <expr> basic_expr
@@ -1671,6 +1673,29 @@ chain_block : /* empty */ { $$ = $<chain>-1; } } ; +typeof_expr : primary_expr + { + if (expr_ops($1)->build_udata == NULL) { + erec_queue(error(&@1, "primary expression type '%s' lacks typeof serialization", expr_ops($1)->name), + state->msgs); + expr_free($1); + YYERROR; + } + + $$ = $1; + } + | typeof_expr DOT primary_expr + { + struct location rhs[] = { + [1] = @2, + [2] = @3, + }; + + $$ = handle_concat_expr(&@$, $$, $1, $3, rhs); + } + ; + + set_block_alloc : /* empty */ { $$ = set_alloc(NULL);
@@ -1685,6 +1710,12 @@ set_block : /* empty */ { $$ = $<set>-1; } $1->key = $3; $$ = $1; } + | set_block TYPEOF typeof_expr stmt_separator + { + $1->key = $3; + datatype_set($1->key, $3->dtype); + $$ = $1; + } | set_block FLAGS set_flag_list stmt_separator { $1->flags = $3;
@@ -1754,6 +1785,17 @@ map_block : /* empty */ { $$ = $<set>-1; } $1->flags |= NFT_SET_MAP; $$ = $1; } + | map_block TYPEOF + typeof_expr COLON typeof_expr + stmt_separator + { + $1->key = $3; + datatype_set($1->key, $3->dtype); + $1->data = $5; + + $1->flags |= NFT_SET_MAP; + $$ = $1; + } | map_block TYPE data_type_expr COLON COUNTER stmt_separator
src/scanner.l +1 -0
@@ -385,6 +385,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "saddr" { return SADDR; } "daddr" { return DADDR; } "type" { return TYPE; } +"typeof" { return TYPEOF; } "vlan" { return VLAN; } "id" { return ID; }
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 6/10 src: add "typeof" build/parse/print support
In reply to Florian WestphalThis patch adds two new expression operations to build and to parse the userdata area that describe the set key and data typeof definitions.
For maps, the grammar enforces either
"type data_type : data_type" or or "typeof expression : expression".
Check both key and data for valid user typeof info first. If they check out, flag set->key_typeof_valid as true and use it for printing the key info.
--- include/expression.h | 4 ++ include/rule.h | 1 + src/mnl.c | 24 ++++++++ src/netlink.c | 129 ++++++++++++++++++++++++++++++++++++++----- src/payload.c | 75 +++++++++++++++++++++++++ src/rule.c | 42 +++++++++++--- 6 files changed, 255 insertions(+), 20 deletions(-)
include/expression.h +4 -0
@@ -10,6 +10,7 @@#include <utils.h> #include <list.h> #include <json.h> +#include <libnftnl/udata.h> /** * enum expr_types
@@ -166,6 +167,9 @@ struct expr_ops { const struct expr *e2);void (*pctx_update)(struct proto_ctx *ctx,const struct expr *expr); +int (*build_udata)(struct nftnl_udata_buf *udbuf, +const struct expr *expr); +struct expr * (*parse_udata)(const struct nftnl_udata *ud); };const struct expr_ops *expr_ops (const struct expr *e);
include/rule.h +1 -0
@@ -307,6 +307,7 @@ struct set {uint32_t policy;bool root;bool automerge; +bool key_typeof_valid;struct {uint32_t size; } desc;
src/mnl.c +24 -0
@@ -811,6 +811,26 @@ err:return NULL ; } +static void set_key_expression (struct netlink_ctx *ctx, +struct expr *expr,uint32_t set_flags, +struct nftnl_udata_buf *udbuf, +unsigned int type) +{ +struct nftnl_udata *nest1, *nest2; + +if (expr->flags &EXPR_F_CONSTANT || + set_flags &NFT_SET_ANONYMOUS || + !expr_ops (expr)->build_udata) +return ; + + nest1 =nftnl_udata_nest_start (udbuf, type); +nftnl_udata_put_u32 (udbuf,NFTNL_UDATA_SET_TYPEOF_EXPR , expr->etype); + nest2 =nftnl_udata_nest_start (udbuf,NFTNL_UDATA_SET_TYPEOF_DATA ); +expr_ops (expr)->build_udata (udbuf, expr); +nftnl_udata_nest_end (udbuf, nest2); +nftnl_udata_nest_end (udbuf, nest1); +} +/* * Set */
@@ -881,6 +901,10 @@ int mnl_nft_set_add(struct netlink_ctx *ctx, const struct cmd *cmd, set->automerge))memory_allocation_error (); +set_key_expression (ctx, set->key, set->flags, udbuf,NFTNL_UDATA_SET_KEY_TYPEOF ); +if (set->data) +set_key_expression (ctx, set->data, set->flags, udbuf,NFTNL_UDATA_SET_DATA_TYPEOF ); +nftnl_set_set_data (nls,NFTNL_SET_USERDATA ,nftnl_udata_buf_data (udbuf),nftnl_udata_buf_len (udbuf));nftnl_udata_buf_free (udbuf);
src/netlink.c +116 -13
192 lines not on this page · raw message
src/payload.c +75 -0
87 lines not on this page · raw message
src/rule.c +35 -7
54 lines not on this page · raw message
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 7/10 mnl: round up the map data size too
In reply to Florian WestphalSame as key: if the size isn't divisible by BITS_PER_BYTE, we need to round up, not down.
Without this, you can't store vlan ids in a map, as they are truncated to 8 bit.
--- src/mnl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
src/mnl.c +1 -1
@@ -861,7 +861,7 @@ int mnl_nft_set_add(struct netlink_ctx *ctx, const struct cmd *cmd,nftnl_set_set_u32 (nls,NFTNL_SET_DATA_TYPE ,dtype_map_to_kernel (set->data->dtype));nftnl_set_set_u32 (nls,NFTNL_SET_DATA_LEN , - set->data->len /BITS_PER_BYTE ); +div_round_up (set->data->len,BITS_PER_BYTE )); }if (set_is_objmap (set->flags))nftnl_set_set_u32 (nls,NFTNL_SET_OBJ_TYPE , set->objtype);
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 8/10 evaluate: print a hint about 'typeof' syntax on 0 keylen
In reply to Florian WestphalIf user says
'type integer; ...' in a set definition, don't just throw an error -- provide a hint that the typeof keyword can be used to provide the needed size information.
--- src/evaluate.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
src/evaluate.c +18 -5
@@ -3307,6 +3307,20 @@ static int setelem_evaluate(struct eval_ctx *ctx, struct expr **expr)return 0 ; } +static int set_key_data_error (struct eval_ctx *ctx,const struct set *set, +const struct datatype *dtype, +const char *name) +{ +const char *hint ="" ; + +if (dtype->size ==0 ) + hint =". Try \"typeof expression\" instead of \"type datatype\"." ; + +return set_error (ctx, set,"unqualified type %s " +"specified in %s definition%s" , + dtype->name, name, hint); +} +static int set_evaluate (struct eval_ctx *ctx,struct set *set) {struct table *table;
@@ -3331,9 +3345,8 @@ static int set_evaluate(struct eval_ctx *ctx, struct set *set)return -1 ;if (set->key->len ==0 ) -return set_error (ctx, set,"unqualified key type %s " -"specified in %s definition" , - set->key->dtype->name, type); +return set_key_data_error (ctx, set, + set->key->dtype, type); }if (set->flags &NFT_SET_INTERVAL && set->key->etype ==EXPR_CONCAT )
@@ -3345,8 +3358,8 @@ static int set_evaluate(struct eval_ctx *ctx, struct set *set) "specify mapping data type");if (set->data->len ==0 && set->data->dtype->type !=TYPE_VERDICT ) -return set_error (ctx, set,"unqualified mapping data " -"type specified in map definition" ); +return set_key_data_error (ctx, set, + set->data->dtype, type); }else if (set_is_objmap (set->flags)) {if (set->data) {assert (set->data->etype ==EXPR_VALUE );
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 9/10 doc: mention 'typeof' as alternative to 'type' keyword
In reply to Florian Westphal--- doc/nft.txt | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
doc/nft.txt +9 -3
@@ -492,7 +492,7 @@ The sets allowed_hosts and allowed_ports need to be created first. The next section describes nft set syntax in more detail. [verse] -*add set* ['family'] 'table' 'set' *{ type* 'type' *;* [*flags* 'flags' *;*] [*timeout* 'timeout' *;*] [*gc-interval* 'gc-interval' *;*] [*elements = {* 'element'[*,* ...] *} ;*] [*size* 'size' *;*] [*policy* 'policy' *;*] [*auto-merge ;*] *}* +*add set* ['family'] 'table' 'set' *{ type* 'type' | *typeof* 'expression' *;* [*flags* 'flags' *;*] [*timeout* 'timeout' *;*] [*gc-interval* 'gc-interval' *;*] [*elements = {* 'element'[*,* ...] *} ;*] [*size* 'size' *;*] [*policy* 'policy' *;*] [*auto-merge ;*] *}* {*delete* | *list* | *flush*} *set* ['family'] 'table' 'set' *list sets* ['family'] *delete set* ['family'] 'table' *handle* 'handle'
@@ -517,6 +517,9 @@ be tuned with the flags that can be specified at set creation time. |type | data type of set elements | string: ipv4_addr, ipv6_addr, ether_addr, inet_proto, inet_service, mark +|typeof | +data type of set element | +expression to derive the data type from |flags | set flags | string: constant, dynamic, interval, timeout
@@ -544,7 +547,7 @@ automatic merge of adjacent/overlapping set elements (only for interval sets) | MAPS ----- [verse] -*add map* ['family'] 'table' 'map' *{ type* 'type' [*flags* 'flags' *;*] [*elements = {* 'element'[*,* ...] *} ;*] [*size* 'size' *;*] [*policy* 'policy' *;*] *}* +*add map* ['family'] 'table' 'map' *{ type* 'type' | *typeof* 'expression' [*flags* 'flags' *;*] [*elements = {* 'element'[*,* ...] *} ;*] [*size* 'size' *;*] [*policy* 'policy' *;*] *}* {*delete* | *list* | *flush*} *map* ['family'] 'table' 'map' *list maps* ['family'] {*add* | *delete*} *element* ['family'] 'table' 'map' *{ elements = {* 'element'[*,* ...] *} ; }*
@@ -565,7 +568,10 @@ Maps store data based on some specific key used as input. They are uniquely iden |Keyword | Description | Type |type | data type of map elements | -string `:' string: ipv4_addr, ipv6_addr, ether_addr, inet_proto, inet_service, mark, counter, quota. Counter and quota can't be used as keys +string: ipv4_addr, ipv6_addr, ether_addr, inet_proto, inet_service, mark, counter, quota. Counter and quota can't be used as keys +|typeof | +data type of set element | +expression to derive the data type from |flags | map flags | string: constant, interval
Signature · 1 line
2.24.1
Florian Westphal
maintainerPATCH v3 10/10 tests: add typeof test cases
In reply to Florian WestphalAdd sets using unspecific string/integer types, one with osf name, other with vlan id. Neither type can be used directly, as they lack the type size information.
--- .../testcases/maps/dumps/typeof_maps_0.nft | 16 ++++++++++ tests/shell/testcases/maps/typeof_maps_0 | 27 +++++++++++++++++ .../testcases/sets/dumps/typeof_sets_0.nft | 19 ++++++++++++ tests/shell/testcases/sets/typeof_sets_0 | 29 +++++++++++++++++++ 4 files changed, 91 insertions(+) create mode 100644 tests/shell/testcases/maps/dumps/typeof_maps_0.nft create mode 100755 tests/shell/testcases/maps/typeof_maps_0 create mode 100644 tests/shell/testcases/sets/dumps/typeof_sets_0.nft create mode 100755 tests/shell/testcases/sets/typeof_sets_0
tests/shell/testcases/maps/dumps/typeof_maps_0.nft new file +16 -0
@@ -0,0 +1,16 @@ +table inet t { + map m1 { + typeof osf name : ct mark + elements = { "Linux" : 0x00000001 } + } + + map m2 { + typeof vlan id : mark + elements = { 1 : 0x00000001 } + } + + chain c { + ct mark set osf name map @m1 + ct mark set osf name map @m2 + } +}
tests/shell/testcases/maps/typeof_maps_0 new file +27 -0
@@ -0,0 +1,27 @@ +#!/bin/bash + +# support for strings and integers in named maps. +# without typeof, this is 'type string' and 'type integer', +# but neither could be used because it lacks size information. + +EXPECTED="table inet t { + map m1 { + typeof osf name : ct mark + elements = { "Linux" : 0x00000001 } + } + + map m2 { + typeof vlan id : mark + elements = { 1 : 0x1, + 4095 : 0x4095 } + } + + chain c { + ct mark set ip daddr map @m1 + ether type vlan meta mark set vlan id map @m2 + } +}" + +set -e +$NFT -f - <<< $EXPECTED +
tests/shell/testcases/sets/dumps/typeof_sets_0.nft new file +19 -0
@@ -0,0 +1,19 @@ +table inet t { + set s1 { + typeof osf name + elements = { "Linux" } + } + + set s2 { + typeof vlan id + elements = { 2, 3, 103 } + } + + chain c1 { + osf name @s1 accept + } + + chain c2 { + vlan id @s2 accept + } +}
tests/shell/testcases/sets/typeof_sets_0 new file +29 -0
@@ -0,0 +1,29 @@ +#!/bin/bash + +# support for strings/typeof in named sets. +# s1 and s2 are identical, they just use different +# ways for declaration. + +EXPECTED="table inet t { + set s1 { + typeof osf name + elements = { \"Linux\" } + } + + set s2 { + typeof vlan id + elements = { 2, 3, 103 } + } + + chain c1 { + osf name @s1 accept + } + + chain c2 { + ether type vlan vlan id @s2 accept + } +}" + +set -e +$NFT -f - <<< $EXPECTED +
Signature · 1 line
2.24.1