add ct expectations support
Subsystems (2)
PATCH v3 1/1 add ct expectations support
This modification allow to directly add/list/delete expectations.
--- doc/libnftables-json.adoc | 52 ++++++++++++++++- doc/stateful-objects.txt | 44 ++++++++++++++ include/linux/netfilter/nf_tables.h | 13 ++++- include/rule.h | 9 +++ src/evaluate.c | 4 ++ src/json.c | 10 ++++ src/mnl.c | 11 ++++ src/netlink.c | 6 ++ src/parser_bison.y | 58 ++++++++++++++++++- src/parser_json.c | 44 ++++++++++++++ src/rule.c | 31 ++++++++++ src/scanner.l | 1 + src/statement.c | 4 ++ tests/py/ip/objects.t | 8 +++ tests/py/ip/objects.t.payload | 4 ++ tests/py/nft-test.py | 4 ++ tests/shell/testcases/listing/0013objects_0 | 8 +++ .../testcases/nft-f/0018ct_expectation_obj_0 | 17 ++++++ 18 files changed, 323 insertions(+), 5 deletions(-) create mode 100755 tests/shell/testcases/nft-f/0018ct_expectation_obj_0
doc/libnftables-json.adoc +49 -3
@@ -23,7 +23,7 @@ libnftables-json - Supported JSON schema by libnftables 'LIST_OBJECT' := 'TABLE' | 'CHAIN' | 'RULE' | 'SET' | 'MAP' | 'ELEMENT' | 'FLOWTABLE' | 'COUNTER' | 'QUOTA' | 'CT_HELPER' | 'LIMIT' | - 'METAINFO_OBJECT' | 'CT_TIMEOUT' + 'METAINFO_OBJECT' | 'CT_TIMEOUT' | 'CT_EXPECTATION' == DESCRIPTION libnftables supports JSON formatted input and output. This is implemented as an
@@ -118,7 +118,7 @@ ____ 'ADD_OBJECT' := 'TABLE' | 'CHAIN' | 'RULE' | 'SET' | 'MAP' | 'ELEMENT' | 'FLOWTABLE' | 'COUNTER | QUOTA' | 'CT_HELPER' | 'LIMIT' | - 'CT_TIMEOUT' + 'CT_TIMEOUT' | 'CT_EXPECTATION' ____ Add a new ruleset element to the kernel.
@@ -162,7 +162,8 @@ ____ 'LIST_OBJECT' := 'TABLE' | 'TABLES' | 'CHAIN' | 'CHAINS' | 'SET' | 'SETS' | 'MAP' | 'MAPS | COUNTER' | 'COUNTERS' | 'QUOTA' | 'QUOTAS' | 'CT_HELPER' | 'CT_HELPERS' | 'LIMIT' | 'LIMITS | RULESET' | - 'METER' | 'METERS' | 'FLOWTABLES' | 'CT_TIMEOUT' + 'METER' | 'METERS' | 'FLOWTABLES' | 'CT_TIMEOUT' | + 'CT_EXPECTATION' ____ List ruleset elements. The plural forms are used to list all objects of that
@@ -597,6 +598,42 @@ This object represents a named conntrack timeout policy. *l3proto*:: The ct timeout object's layer 3 protocol, e.g. *"ip"* or *"ip6"*. +=== CT EXPECTATION +[verse] +____ +*{ "ct expectation": { + "family":* 'STRING'*, + "table":* 'STRING'*, + "name":* 'STRING'*, + "handle":* 'NUMBER'*, + "l3proto":* 'STRING' + "protocol":* 'CTH_PROTO'*, + "dport":* 'NUMBER'*, + "timeout:* 'NUMBER'*, +*}}* + +'CTH_PROTO' := *"tcp"* | *"udp"* | *"dccp"* | *"sctp"* | *"gre"* | *"icmpv6"* | *"icmp"* | *"generic"* +____ + +This object represents a named conntrack expectation. + +*family*:: + The table's family. +*table*:: + The table's name. +*name*:: + The ct expectation object's name. +*handle*:: + The ct expectation object's handle. In input, it is used by *delete* command only. +*l3proto*:: + The ct expectation object's layer 3 protocol, e.g. *"ip"* or *"ip6"*. +*protocol*:: + The ct expectation object's layer 4 protocol. +*dport*:: + The destination port of the expected connection. +*timeout*:: + The time in second that this expectation will live. + == STATEMENTS Statements are the building blocks for rules. Each rule consists of at least one.
@@ -1004,6 +1041,15 @@ Assign connection tracking timeout policy. *ct timeout*:: CT timeout reference. +=== CT EXPECTATION +[verse] +*{ "ct expectation":* 'EXPRESSION' *}* + +Assign connection tracking expectation. + +*ct expectation*:: + CT expectation reference. + === XT [verse] *{ "xt": null }*
doc/stateful-objects.txt +44 -0
50 lines not on this page · raw message
include/linux/netfilter/nf_tables.h +12 -1
@@ -1443,6 +1443,16 @@ enum nft_ct_timeout_timeout_attributes { };#define NFTA_CT_TIMEOUT_MAX (__NFTA_CT_TIMEOUT_MAX - 1) +enum nft_ct_expect_attributes { +NFTA_CT_EXPECT_UNSPEC , +NFTA_CT_EXPECT_L3PROTO , +NFTA_CT_EXPECT_L4PROTO , +NFTA_CT_EXPECT_DPORT , +NFTA_CT_EXPECT_TIMEOUT , + __NFTA_CT_EXPECT_MAX, +}; +#define NFTA_CT_EXPECT_MAX (__NFTA_CT_EXPECT_MAX - 1) +#define NFT_OBJECT_UNSPEC 0#define NFT_OBJECT_COUNTER 1#define NFT_OBJECT_QUOTA 2
@@ -1452,7 +1462,8 @@ enum nft_ct_timeout_timeout_attributes {#define NFT_OBJECT_TUNNEL 6#define NFT_OBJECT_CT_TIMEOUT 7#define NFT_OBJECT_SECMARK 8 -#define __NFT_OBJECT_MAX 9 +#define NFT_OBJECT_CT_EXPECT 9 +#define __NFT_OBJECT_MAX 10#define NFT_OBJECT_MAX (__NFT_OBJECT_MAX - 1)/**
include/rule.h +9 -0
@@ -351,6 +351,13 @@ struct ct_timeout {struct list_head timeout_list; }; +struct ct_expect { +uint16_t l3proto; +uint8_t l4proto; +uint16_t dport; +uint32_t timeout; +}; +struct limit {uint64_t rate;uint64_t unit;
@@ -385,6 +392,7 @@ struct obj {struct limit limit;struct ct_timeout ct_timeout;struct secmark secmark; +struct ct_expect ct_expect; }; };
@@ -519,6 +527,7 @@ enum cmd_obj {CMD_OBJ_CT_TIMEOUT ,CMD_OBJ_SECMARK ,CMD_OBJ_SECMARKS , + CMD_OBJ_CT_EXPECT, }; struct markup {
src/evaluate.c +4 -0
@@ -3441,6 +3441,7 @@ static int cmd_evaluate_add(struct eval_ctx *ctx, struct cmd *cmd)case CMD_OBJ_LIMIT :case CMD_OBJ_CT_TIMEOUT :case CMD_OBJ_SECMARK : +case CMD_OBJ_CT_EXPECT :return obj_evaluate (ctx, cmd->object);default :BUG ("invalid command object type %u\n" , cmd->obj);
@@ -3469,6 +3470,7 @@ static int cmd_evaluate_delete(struct eval_ctx *ctx, struct cmd *cmd)case CMD_OBJ_CT_TIMEOUT :case CMD_OBJ_LIMIT :case CMD_OBJ_SECMARK : +case CMD_OBJ_CT_EXPECT :return 0 ;default :BUG ("invalid command object type %u\n" , cmd->obj);
@@ -3612,6 +3614,8 @@ static int cmd_evaluate_list(struct eval_ctx *ctx, struct cmd *cmd)return cmd_evaluate_list_obj (ctx, cmd,NFT_OBJECT_LIMIT );case CMD_OBJ_SECMARK :return cmd_evaluate_list_obj (ctx, cmd,NFT_OBJECT_SECMARK ); +case CMD_OBJ_CT_EXPECT : +return cmd_evaluate_list_obj (ctx, cmd,NFT_OBJECT_CT_EXPECT );case CMD_OBJ_COUNTERS :case CMD_OBJ_QUOTAS :case CMD_OBJ_CT_HELPERS :
src/json.c +10 -0
@@ -325,6 +325,16 @@ static json_t *obj_print_json(const struct obj *obj)json_object_update (root, tmp);json_decref (tmp);break ; +case NFT_OBJECT_CT_EXPECT : + tmp =json_pack ("{s:o, s:I, s:I, s:s}" , +"protocol" , +proto_name_json (obj->ct_expect.l4proto), +"dport" , obj->ct_expect.dport, +"timeout" , obj->ct_expect.timeout, +"l3proto" ,family2str (obj->ct_expect.l3proto)); +json_object_update (root, tmp); +json_decref (tmp); +break ;case NFT_OBJECT_LIMIT : rate = obj->limit.rate; burst = obj->limit.burst;
src/mnl.c +11 -0
@@ -954,6 +954,17 @@ int mnl_nft_obj_add(struct netlink_ctx *ctx, const struct cmd *cmd,nftnl_obj_set (nlo,NFTNL_OBJ_CT_TIMEOUT_ARRAY , obj->ct_timeout.timeout);break ; +case NFT_OBJECT_CT_EXPECT : +if (obj->ct_expect.l3proto) +nftnl_obj_set_u16 (nlo,NFTNL_OBJ_CT_EXPECT_L3PROTO , + obj->ct_expect.l3proto); +nftnl_obj_set_u8 (nlo,NFTNL_OBJ_CT_EXPECT_L4PROTO , + obj->ct_expect.l4proto); +nftnl_obj_set_u16 (nlo,NFTNL_OBJ_CT_EXPECT_DPORT , + obj->ct_expect.dport); +nftnl_obj_set_u32 (nlo,NFTNL_OBJ_CT_EXPECT_TIMEOUT , + obj->ct_expect.timeout); +break ;case NFT_OBJECT_SECMARK :nftnl_obj_set_str (nlo,NFTNL_OBJ_SECMARK_CTX , obj->secmark.ctx);
src/netlink.c +6 -0
@@ -989,6 +989,12 @@ struct obj *netlink_delinearize_obj(struct netlink_ctx *ctx, obj->limit.flags =nftnl_obj_get_u32 (nlo,NFTNL_OBJ_LIMIT_FLAGS );break ; +case NFT_OBJECT_CT_EXPECT : + obj->ct_expect.l3proto =nftnl_obj_get_u16 (nlo,NFTNL_OBJ_CT_EXPECT_L3PROTO ); + obj->ct_expect.l4proto =nftnl_obj_get_u8 (nlo,NFTNL_OBJ_CT_EXPECT_L4PROTO ); + obj->ct_expect.dport =nftnl_obj_get_u16 (nlo,NFTNL_OBJ_CT_EXPECT_DPORT ); + obj->ct_expect.timeout =nftnl_obj_get_u32 (nlo,NFTNL_OBJ_CT_EXPECT_TIMEOUT ); +break ; } obj->type = type;
src/parser_bison.y +57 -1
118 lines not on this page · raw message
src/parser_json.c +44 -0
74 lines not on this page · raw message
src/rule.c +31 -0
@@ -1404,6 +1404,7 @@ void cmd_free(struct cmd *cmd)case CMD_OBJ_QUOTA :case CMD_OBJ_CT_HELPER :case CMD_OBJ_CT_TIMEOUT : +case CMD_OBJ_CT_EXPECT :case CMD_OBJ_LIMIT :case CMD_OBJ_SECMARK :obj_free (cmd->object);
@@ -1501,6 +1502,7 @@ static int do_command_add(struct netlink_ctx *ctx, struct cmd *cmd, bool excl)case CMD_OBJ_QUOTA :case CMD_OBJ_CT_HELPER :case CMD_OBJ_CT_TIMEOUT : +case CMD_OBJ_CT_EXPECT :case CMD_OBJ_LIMIT :case CMD_OBJ_SECMARK :return mnl_nft_obj_add (ctx, cmd, flags);
@@ -1589,6 +1591,8 @@ static int do_command_delete(struct netlink_ctx *ctx, struct cmd *cmd)return mnl_nft_obj_del (ctx, cmd,NFT_OBJECT_CT_HELPER );case CMD_OBJ_CT_TIMEOUT :return mnl_nft_obj_del (ctx, cmd,NFT_OBJECT_CT_TIMEOUT ); +case CMD_OBJ_CT_EXPECT : +return mnl_nft_obj_del (ctx, cmd,NFT_OBJECT_CT_EXPECT );case CMD_OBJ_LIMIT :return mnl_nft_obj_del (ctx, cmd,NFT_OBJECT_LIMIT );case CMD_OBJ_SECMARK :
@@ -1818,6 +1822,26 @@ static void obj_print_data(const struct obj *obj,print_proto_timeout_policy (obj->ct_timeout.l4proto, obj->ct_timeout.timeout, opts, octx);break ; +case NFT_OBJECT_CT_EXPECT : +nft_print (octx," %s {" , obj->handle.obj.name); +if (nft_output_handle (octx)) +nft_print (octx," # handle %" PRIu64, obj->handle.handle.id); +nft_print (octx,"%s" , opts->nl); +nft_print (octx,"%s%sprotocol " , opts->tab, opts->tab); +print_proto_name_proto (obj->ct_expect.l4proto, octx); +nft_print (octx,"%s" , opts->stmt_separator); +nft_print (octx,"%s%sdport %d%s" , + opts->tab, opts->tab, + obj->ct_expect.dport, + opts->stmt_separator); +nft_print (octx,"%s%stimeout " , opts->tab, opts->tab); +time_print (obj->ct_expect.timeout, octx); +nft_print (octx,"%s" , opts->stmt_separator); +nft_print (octx,"%s%sl3proto %s%s" , + opts->tab, opts->tab, +family2str (obj->ct_expect.l3proto), + opts->stmt_separator); +break ;case NFT_OBJECT_LIMIT : {bool inv = obj->limit.flags &NFT_LIMIT_F_INV ;const char *data_unit;
@@ -1867,6 +1891,7 @@ static const char * const obj_type_name_array[] = { [NFT_OBJECT_LIMIT] = "limit", [NFT_OBJECT_CT_TIMEOUT] = "ct timeout", [NFT_OBJECT_SECMARK] = "secmark", + [NFT_OBJECT_CT_EXPECT] = "ct expectation", };const char *obj_type_name (enum stmt_types type)
@@ -1883,6 +1908,7 @@ static uint32_t obj_type_cmd_array[NFT_OBJECT_MAX + 1] = { [NFT_OBJECT_LIMIT] = CMD_OBJ_LIMIT, [NFT_OBJECT_CT_TIMEOUT] = CMD_OBJ_CT_TIMEOUT, [NFT_OBJECT_SECMARK] = CMD_OBJ_SECMARK, + [NFT_OBJECT_CT_EXPECT] = CMD_OBJ_CT_EXPECT, };uint32_t obj_type_to_cmd (uint32_t type)
@@ -2241,6 +2267,8 @@ static int do_command_list(struct netlink_ctx *ctx, struct cmd *cmd)return do_list_obj (ctx, cmd,NFT_OBJECT_CT_HELPER );case CMD_OBJ_CT_TIMEOUT :return do_list_obj (ctx, cmd,NFT_OBJECT_CT_TIMEOUT ); +case CMD_OBJ_CT_EXPECT : +return do_list_obj (ctx, cmd,NFT_OBJECT_CT_EXPECT );case CMD_OBJ_LIMIT :case CMD_OBJ_LIMITS :return do_list_obj (ctx, cmd,NFT_OBJECT_LIMIT );
@@ -2461,6 +2489,9 @@ struct cmd *cmd_alloc_obj_ct(enum cmd_ops op, int type, const struct handle *h,case NFT_OBJECT_CT_TIMEOUT : cmd_obj =CMD_OBJ_CT_TIMEOUT ;break ; +case NFT_OBJECT_CT_EXPECT : + cmd_obj =CMD_OBJ_CT_EXPECT ; +break ;default :BUG ("missing type mapping" ); }
src/scanner.l +1 -0
@@ -520,6 +520,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "reply" { return REPLY; } "direction" { return DIRECTION; } "event" { return EVENT; } +"expectation" { return EXPECTATION; } "expiration" { return EXPIRATION; } "helper" { return HELPER; } "helpers" { return HELPERS; }
src/statement.c +4 -0
@@ -208,6 +208,7 @@ static const char *objref_type[NFT_OBJECT_MAX + 1] = { [NFT_OBJECT_LIMIT] = "limit", [NFT_OBJECT_CT_TIMEOUT] = "ct timeout", [NFT_OBJECT_SECMARK] = "secmark", + [NFT_OBJECT_CT_EXPECT] = "ct expectation", };const char *objref_type_name (uint32_t type)
@@ -227,6 +228,9 @@ static void objref_stmt_print(const struct stmt *stmt, struct output_ctx *octx)case NFT_OBJECT_CT_TIMEOUT :nft_print (octx,"ct timeout set " );break ; +case NFT_OBJECT_CT_EXPECT : +nft_print (octx,"ct expectation set " ); +break ;default :nft_print (octx,"%s name " ,objref_type_name (stmt->objref.type));
tests/py/ip/objects.t +8 -0
@@ -41,3 +41,11 @@ limit name tcp dport map {443 : "lim1", 80 : "lim2", 22 : "lim1"};ok %cttime5 type ct timeout {protocol tcp; policy = { estalbished:100 } ;};fail ct timeout set "cttime1";ok + +# ct expectation +%ctexpect1 type ct expectation { protocol tcp; dport 1234; timeout 2m; };ok +%ctexpect2 type ct expectation { protocol udp; };fail +%ctexpect3 type ct expectation { protocol tcp; dport 4321; };fail +%ctexpect4 type ct expectation { protocol udp; dport 9876; timeout 2m; l3proto ip; };ok + +ct expectation set "ctexpect1";ok
tests/py/ip/objects.t.payload +4 -0
@@ -63,3 +63,7 @@ ip test-ip4 output # ct timeout set "cttime1" ip test-ip4 output [ objref type 7 name cttime1 ] + +# ct expectation set "ctexpect1" +ip test-ip4 output + [ objref type 9 name ctexpect1 ]
tests/py/nft-test.py +4 -0
@@ -1109,6 +1109,10 @@ def obj_process(obj_line, filename, lineno): obj_type = "ct timeout" tokens[3] = "" + if obj_type == "ct" and tokens[3] == "expectation": + obj_type = "ct expectation" + tokens[3] = "" + if len(tokens) > 3: obj_spcf = " ".join(tokens[3:])
tests/shell/testcases/listing/0013objects_0 +8 -0
@@ -18,6 +18,13 @@ EXPECTED="table ip test { policy = { unreplied: 15, replied: 12 } } + ct expectation ctexpect { + protocol tcp + dport 5432 + timeout 1h + l3proto ip + } + chain input { } }"
@@ -29,6 +36,7 @@ $NFT add chain test input $NFT add quota test https-quota 25 mbytes $NFT add ct helper test cthelp { type \"sip\" protocol tcp \; } $NFT add ct timeout test cttime { protocol udp \; policy = {replied: 12, unreplied: 15 } \; } +$NFT add ct expectation test ctexpect { protocol tcp \; dport 5432 \; timeout 1h \; } $NFT add table test-ip GET="$($NFT list table test)"
tests/shell/testcases/nft-f/0018ct_expectation_obj_0 new file +17 -0
@@ -0,0 +1,17 @@ +#!/bin/bash + +EXPECTED='table ip filter { + ct expectation ctexpect{ + protocol tcp + dport 9876 + timeout 1m + l3proto ip + } + + chain c { + ct expectation set "ctexpect" + } +}' + +set -e +$NFT -f - <<< $EXPECTED
Signature · 1 line
2.21.0
PATCH v3 1/1 netfilter: nft_ct: add ct expectations support
This patch allows to add, list and delete expectations via nft objref infrastructure and assigning these expectations via nft rule.
This allows manual port triggering when no helper is defined to manage a specific protocol. For example, if I have an online game which protocol is based on initial connection to TCP port 9753 of the server, and where the server opens a connection to port 9876, I can set rules as follow:
table ip filter {
ct expectation mygame {
protocol udp;
dport 9876;
}
chain input {
type filter hook input priority 0; policy drop;
tcp dport 9753 ct expectation set "mygame";
}
chain output {
type filter hook output priority 0; policy drop;
udp dport 9876 ct status expected accept;
}
}--- include/uapi/linux/netfilter/nf_tables.h | 13 ++- net/netfilter/nft_ct.c | 121 ++++++++++++++++++++++- 2 files changed, 131 insertions(+), 3 deletions(-)
include/uapi/linux/netfilter/nf_tables.h +12 -1
@@ -1447,6 +1447,16 @@ enum nft_ct_timeout_timeout_attributes { };#define NFTA_CT_TIMEOUT_MAX (__NFTA_CT_TIMEOUT_MAX - 1) +enum nft_ct_expectation_attributes { +NFTA_CT_EXPECT_UNSPEC , +NFTA_CT_EXPECT_L3PROTO , +NFTA_CT_EXPECT_L4PROTO , +NFTA_CT_EXPECT_DPORT , +NFTA_CT_EXPECT_TIMEOUT , + __NFTA_CT_EXPECT_MAX, +}; +#define NFTA_CT_EXPECT_MAX (__NFTA_CT_EXPECT_MAX - 1) +#define NFT_OBJECT_UNSPEC 0#define NFT_OBJECT_COUNTER 1#define NFT_OBJECT_QUOTA 2
@@ -1456,7 +1466,8 @@ enum nft_ct_timeout_timeout_attributes {#define NFT_OBJECT_TUNNEL 6#define NFT_OBJECT_CT_TIMEOUT 7#define NFT_OBJECT_SECMARK 8 -#define __NFT_OBJECT_MAX 9 +#define NFT_OBJECT_CT_EXPECT 9 +#define __NFT_OBJECT_MAX 10#define NFT_OBJECT_MAX (__NFT_OBJECT_MAX - 1)/**
net/netfilter/nft_ct.c +119 -2
157 lines not on this page · raw message
Signature · 1 line
2.21.0
Pablo Neira Ayuso
maintainerRe: [PATCH nf-next,v3] netfilter: nft_ct: add ct expectations support
Quoted 8 lines · Stéphane Veyret
This patch allows to add, list and delete expectations via nft objref infrastructure and assigning these expectations via nft rule.
This allows manual port triggering when no helper is defined to manage a specific protocol. For example, if I have an online game which protocol is based on initial connection to TCP port 9753 of the server, and where the server opens a connection to port 9876, I can set rules as follow:
Quoted 4 lines
table ip filter {
ct expectation mygame {
protocol udp;
dport 9876;I think we should set a maximum number of expectations to be created, as a mandatory field, eg.
size 10;
Quoted 12 lines
}
chain input {
type filter hook input priority 0; policy drop;
tcp dport 9753 ct expectation set "mygame";
}
chain output {
type filter hook output priority 0; policy drop;
udp dport 9876 ct status expected accept;
}
}[...]
Quoted 23 lines
net/netfilter/nft_ct.c +8
-0@@ -24,6 +24,7 @@#include <net/netfilter/nf_conntrack_labels.h> #include <net/netfilter/nf_conntrack_timeout.h> #include <net/netfilter/nf_conntrack_l4proto.h> +#include <net/netfilter/nf_conntrack_expect.h> struct nft_ct {enum nft_ct_keys key:8 ;@@ -790,6 +791,114 @@ static struct nft_expr_type nft_notrack_type __read_mostly = { .owner = THIS_MODULE, }; +struct nft_ct_expect_obj { +int l3num; +u8 l4proto; +__be16 dport; +u32 timeout; +}; +
net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 810
Quoted 10 lines
net/netfilter/nft_ct.c +10
-0+static int nft_ct_expect_obj_init (const struct nft_ctx *ctx, +const struct nlattr *const tb[], +struct nft_object *obj) +{ +struct nft_ct_expect_obj *priv =nft_obj_data (obj); +int ret; + +if (!tb[NFTA_CT_EXPECT_L4PROTO ] || + !tb[NFTA_CT_EXPECT_DPORT ] || + !tb[NFTA_CT_EXPECT_TIMEOUT ])
Coding style: Align parameter to parens:
if (!tb[NFTA_CT_EXPECT_L4PROTO] ||
!tb[NFTA_CT_EXPECT_DPORT] ||
!tb[NFTA_CT_EXPECT_TIMEOUT])
return -EINVAL;net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 813
Quoted 1 line
net/netfilter/nft_ct.c +1
-0+ priv->l3num = ctx->family;
priv->l3num is only set and never used, remove it. You'll also have to remove NFTA_CT_EXPECT_L3PROTO.
net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 821
Quoted 8 lines
net/netfilter/nft_ct.c +8
-0+if (tb[NFTA_CT_EXPECT_L3PROTO ]) + priv->l3num =ntohs (nla_get_be16 (tb[NFTA_CT_EXPECT_L3PROTO ])); + + priv->l4proto =nla_get_u8 (tb[NFTA_CT_EXPECT_L4PROTO ]); + priv->dport =nla_get_be16 (tb[NFTA_CT_EXPECT_DPORT ]); + priv->timeout =nla_get_u32 (tb[NFTA_CT_EXPECT_TIMEOUT ]); + + ret =nf_ct_netns_get (ctx->net, ctx->family);
Just:
return nf_ct_netns_get(ctx->net, ctx->family);
should be fine.
Quoted 12 lines
net/netfilter/nft_ct.c +12
-0+if (ret <0 ) +return ret; + +return 0 ; +} + +static void nft_ct_expect_obj_destroy (const struct nft_ctx *ctx, +struct nft_object *obj) +{ +nf_ct_netns_put (ctx->net, ctx->family); +} +
net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 843
Quoted 10 lines
net/netfilter/nft_ct.c +10
-0+static int nft_ct_expect_obj_dump (struct sk_buff *skb, +struct nft_object *obj,bool reset) +{ +const struct nft_ct_expect_obj *priv =nft_obj_data (obj); + +if (nla_put_be16 (skb,NFTA_CT_EXPECT_L3PROTO ,htons (priv->l3num)) || +nla_put_u8 (skb,NFTA_CT_EXPECT_L4PROTO , priv->l4proto) || +nla_put_be16 (skb,NFTA_CT_EXPECT_DPORT , priv->dport) || +nla_put_u32 (skb,NFTA_CT_EXPECT_TIMEOUT , priv->timeout)) +return -1 ;
Coding style: Align parameter to parens:
if (nla_put_be16(skb, NFTA_CT_EXPECT_L3PROTO, htons(priv->l3num)) ||
nla_put_u8(skb, NFTA_CT_EXPECT_L4PROTO, priv->l4proto) ||
nla_put_be16(skb, NFTA_CT_EXPECT_DPORT, priv->dport) ||
nla_put_u32(skb, NFTA_CT_EXPECT_TIMEOUT, priv->timeout))
return -1;net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 856
Quoted 12 lines
net/netfilter/nft_ct.c +12
-0+return 0 ; +} + +static void nft_ct_expect_obj_eval (struct nft_object *obj, +struct nft_regs *regs, +const struct nft_pktinfo *pkt) +{ +const struct nft_ct_expect_obj *priv =nft_obj_data (obj); +enum ip_conntrack_info ctinfo; +struct nf_conn *ct =nf_ct_get (pkt->skb, &ctinfo); +int dir =CTINFO2DIR (ctinfo); +struct nf_conntrack_expect *exp;
Please, revert xmas tree for variable definitions, ie.
const struct nft_ct_expect_obj *priv = nft_obj_data(obj); struct nf_conntrack_expect *exp; enum ip_conntrack_info ctinfo; int dir = CTINFO2DIR(ctinfo); struct nf_conn *ct;
Then, you have to check if ct is unset or is untrackedie.
ct = nf_ct_get(pkt->skb, &ctinfo);
if (!ct || ctinfo == IP_CT_UNTRACKED)
goto err;
...
err:
regs->verdict.code = NFT_BREAK;net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 858
Quoted 1 line
net/netfilter/nft_ct.c +1
-0+nf_ct_helper_ext_add (ct,GFP_ATOMIC );
I think you don't need nf_ct_helper_ext_add(...);
net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 868
Quoted 10 lines
net/netfilter/nft_ct.c +10
-0+ exp =nf_ct_expect_alloc (ct); +if (exp ==NULL ) { + regs->verdict.code =NF_DROP ; +return ; + } + +nf_ct_expect_init (exp,NF_CT_EXPECT_CLASS_DEFAULT , priv->l3num, + &ct->tuplehash[!dir].tuple.src.u3, + &ct->tuplehash[!dir].tuple.dst.u3, + priv->l4proto,NULL , &priv->dport);
Coding style: Align parameter to parens:
nf_ct_expect_init(exp, NF_CT_EXPECT_CLASS_DEFAULT, priv->l3num,
&ct->tuplehash[!dir].tuple.src.u3,
&ct->tuplehash[!dir].tuple.dst.u3,
priv->l4proto, NULL, &priv->dport);net/netfilter/nft_ct.c static struct nft_expr_type nft_notrack_type __read_mostly = { · line 873
Quoted 5 lines
net/netfilter/nft_ct.c +5
-0+ exp->timeout.expires = jiffies + priv->timeout *HZ ; + +if (nf_ct_expect_related (exp) !=0 ) { + regs->verdict.code =NF_DROP ; + }
No need for curly braces here, with single statement, the following is fine:
if (nf_ct_expect_related(exp) != 0)
regs->verdict.code = NF_DROP;Thanks for submitting your patch.
Re: [PATCH nf-next,v3] netfilter: nft_ct: add ct expectations support
Thank you Pablo for your feedback. See my comments below.
Quoted 4 lines · Pablo Neira Ayuso
I think we should set a maximum number of expectations to be created, as a mandatory field, eg.
size 10;
I feel it would be complicated to set, as it would require to keep track of all expectations set using this definition, and moreover, check if those expectations are still alive, or deleted because already used or timed out.
Quoted 3 lines
Quoted 1 line
+
priv->l3num=ctx->family;
priv->l3numis only set and never used, remove it. You'll also have to
priv->l3num is used for setting expectation, in function nft_ct_expect_obj_eval (see the call to nf_ct_expect_init).
Quoted 3 lines
Quoted 1 line
+
nf_ct_helper_ext_add(ct, GFP_ATOMIC);I think you don't need
nf_ct_helper_ext_add(...);
Actually, I had to add this instruction. While testing the feature, i saw that, even if no helper is really set on the connection, expectation functions require NF_CT_EXT_HELPER to be set on master connection. Without it, there would be some null pointer exception, which fortunately is checked at expectation creation by __nf_ct_expect_check.
Regards,
Stéphane.
Pablo Neira Ayuso
maintainerRe: [PATCH nf-next,v3] netfilter: nft_ct: add ct expectations support
On Wed, May 22, 2019 at 01:39:57PM +0200, Stéphane Veyret wrote:
[...]
Quoted 10 lines · Pablo Neira Ayuso
Quoted 4 lines
I think we should set a maximum number of expectations to be created, as a mandatory field, eg.
size 10;I feel it would be complicated to set, as it would require to keep track of all expectations set using this definition, and moreover, check if those expectations are still alive, or deleted because already used or timed out.
You can use the 'expecting[0]' counter in the ct helper extension to limit the number of expectations per conntrack entry:
struct nf_conn_help {
[...]
/* Current number of expected connections */
u8 expecting[NF_CT_MAX_EXPECT_CLASSES];
};You have to check if the ct helper area exists in first place.
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
+
priv->l3num=ctx->family;
priv->l3numis only set and never used, remove it. You'll also have to
priv->l3numis used for setting expectation, in functionnft_ct_expect_obj_eval(see the call tonf_ct_expect_init).
OK, thanks for explaining.
Still this new expectation extension won't work with NFPROTO_INET tables though, since the expectation infrastructure does not know what to do with NFPROTO_INET.
If NFPROTO_INET is specified, you could just fetch the l3proto from the ct object, from the packet path by when you call nf_ct_expect_init().
Quoted 10 lines
Quoted 3 lines
Quoted 1 line
+
nf_ct_helper_ext_add(ct, GFP_ATOMIC);I think you don't need
nf_ct_helper_ext_add(...);Actually, I had to add this instruction. While testing the feature, i saw that, even if no helper is really set on the connection, expectation functions require
NF_CT_EXT_HELPERto be set on master connection. Without it, there would be some null pointer exception, which fortunately is checked at expectation creation by__nf_ct_expect_check.
Thanks again for explaining.
You still have to check if the conntrack already has a helper extensions, otherwise I'm afraid this resets it for this conntrack.
PATCH v3 1/2 src: add ct expectation support
In reply to Stéphane VeyretAdd support for ct expectation objects, used to define specific expectations.
--- include/libnftnl/object.h | 7 + include/linux/netfilter/nf_tables.h | 13 +- include/obj.h | 7 + src/Makefile.am | 1 + src/obj/ct_expect.c | 193 ++++++++++++++++++++++++++++ src/object.c | 1 + 6 files changed, 221 insertions(+), 1 deletion(-) create mode 100644 src/obj/ct_expect.c
include/libnftnl/object.h +7 -0
@@ -70,6 +70,13 @@ enum { NFTNL_OBJ_CT_TIMEOUT_ARRAY, }; +enum { +NFTNL_OBJ_CT_EXPECT_L3PROTO =NFTNL_OBJ_BASE , +NFTNL_OBJ_CT_EXPECT_L4PROTO , +NFTNL_OBJ_CT_EXPECT_DPORT , +NFTNL_OBJ_CT_EXPECT_TIMEOUT , +}; +enum {NFTNL_OBJ_LIMIT_RATE =NFTNL_OBJ_BASE ,NFTNL_OBJ_LIMIT_UNIT ,
include/linux/netfilter/nf_tables.h +12 -1
@@ -1429,6 +1429,16 @@ enum nft_ct_timeout_attributes { };#define NFTA_CT_TIMEOUT_MAX (__NFTA_CT_TIMEOUT_MAX - 1) +enum nft_ct_expectation_attributes { +NFTA_CT_EXPECT_UNSPEC , +NFTA_CT_EXPECT_L3PROTO , +NFTA_CT_EXPECT_L4PROTO , +NFTA_CT_EXPECT_DPORT , +NFTA_CT_EXPECT_TIMEOUT , + __NFTA_CT_EXPECT_MAX, +}; +#define NFTA_CT_EXPECT_MAX (__NFTA_CT_EXPECT_MAX - 1) +#define NFT_OBJECT_UNSPEC 0#define NFT_OBJECT_COUNTER 1#define NFT_OBJECT_QUOTA 2
@@ -1438,7 +1448,8 @@ enum nft_ct_timeout_attributes {#define NFT_OBJECT_TUNNEL 6#define NFT_OBJECT_CT_TIMEOUT 7#define NFT_OBJECT_SECMARK 8 -#define __NFT_OBJECT_MAX 9 +#define NFT_OBJECT_CT_EXPECT 9 +#define __NFT_OBJECT_MAX 10#define NFT_OBJECT_MAX (__NFT_OBJECT_MAX - 1)/**
include/obj.h +7 -0
@@ -42,6 +42,12 @@ struct nftnl_obj {uint8_t l4proto;uint32_t timeout[NFTNL_CTTIMEOUT_ARRAY_MAX ]; } ct_timeout; +struct nftnl_obj_ct_expect { +uint16_t l3proto; +uint8_t l4proto; +uint16_t dport; +uint32_t timeout; + } ct_expect;struct nftnl_obj_limit {uint64_t rate;uint64_t unit;
@@ -99,6 +105,7 @@ extern struct obj_ops obj_ops_counter;extern struct obj_ops obj_ops_quota;extern struct obj_ops obj_ops_ct_helper;extern struct obj_ops obj_ops_ct_timeout; +extern struct obj_ops obj_ops_ct_expect;extern struct obj_ops obj_ops_limit;extern struct obj_ops obj_ops_tunnel;extern struct obj_ops obj_ops_secmark;
src/Makefile.am +1 -0
@@ -65,4 +65,5 @@ libnftnl_la_SOURCES = utils.c \ obj/limit.c \ obj/ct_timeout.c \ obj/secmark.c \ + obj/ct_expect.c \ libnftnl.map
src/obj/ct_expect.c new file +193 -0
193 lines not on this page · raw message
src/object.c +1 -0
@@ -33,6 +33,7 @@ static struct obj_ops *obj_ops[__NFT_OBJECT_MAX] = { [NFT_OBJECT_TUNNEL] = &obj_ops_tunnel, [NFT_OBJECT_CT_TIMEOUT] = &obj_ops_ct_timeout, [NFT_OBJECT_SECMARK] = &obj_ops_secmark, + [NFT_OBJECT_CT_EXPECT] = &obj_ops_ct_expect, };static struct obj_ops *nftnl_obj_ops_lookup (uint32_t type)
Signature · 1 line
2.21.0
PATCH v3 2/2 examples: add ct expectation examples
In reply to Stéphane VeyretAdd examples for ct expectations.
Add, list and delete ct expectation objects from specified table. Add expectation object to rule.
--- examples/Makefile.am | 16 +++ examples/nft-ct-expectation-add.c | 152 +++++++++++++++++++++++ examples/nft-ct-expectation-del.c | 128 +++++++++++++++++++ examples/nft-ct-expectation-get.c | 144 ++++++++++++++++++++++ examples/nft-rule-ct-expectation-add.c | 163 +++++++++++++++++++++++++ 5 files changed, 603 insertions(+) create mode 100644 examples/nft-ct-expectation-add.c create mode 100644 examples/nft-ct-expectation-del.c create mode 100644 examples/nft-ct-expectation-get.c create mode 100644 examples/nft-rule-ct-expectation-add.c
examples/Makefile.am +16 -0
@@ -29,10 +29,14 @@ check_PROGRAMS = nft-table-add \ nft-flowtable-get \ nft-ruleset-get \ nft-compat-get \ + nft-ct-expectation-add \ + nft-ct-expectation-del \ + nft-ct-expectation-get \ nft-ct-helper-add \ nft-ct-helper-get \ nft-ct-helper-del \ nft-rule-ct-helper-add \ + nft-rule-ct-expectation-add \ nft-rule-ct-timeout-add nft_table_add_SOURCES = nft-table-add.c
@@ -122,6 +126,15 @@ nft_ruleset_get_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} nft_compat_get_SOURCES = nft-compat-get.c nft_compat_get_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} +nft_ct_expectation_add_SOURCES = nft-ct-expectation-add.c +nft_ct_expectation_add_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} + +nft_ct_expectation_del_SOURCES = nft-ct-expectation-del.c +nft_ct_expectation_del_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} + +nft_ct_expectation_get_SOURCES = nft-ct-expectation-get.c +nft_ct_expectation_get_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} + nft_ct_helper_add_SOURCES = nft-ct-helper-add.c nft_ct_helper_add_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS}
@@ -134,5 +147,8 @@ nft_ct_helper_del_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} nft_rule_ct_helper_add_SOURCES = nft-rule-ct-helper-add.c nft_rule_ct_helper_add_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} +nft_rule_ct_expectation_add_SOURCES = nft-rule-ct-expectation-add.c +nft_rule_ct_expectation_add_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS} + nft_rule_ct_timeout_add_SOURCES = nft-rule-ct-timeout-add.c nft_rule_ct_timeout_add_LDADD = ../src/libnftnl.la ${LIBMNL_LIBS}
examples/nft-ct-expectation-add.c new file +152 -0
152 lines not on this page · raw message
examples/nft-ct-expectation-del.c new file +128 -0
128 lines not on this page · raw message
examples/nft-ct-expectation-get.c new file +144 -0
144 lines not on this page · raw message
examples/nft-rule-ct-expectation-add.c new file +163 -0
163 lines not on this page · raw message
Signature · 1 line
2.21.0