struct parser_state;
#ifdef HAVE_LIBREADLINE
-extern int cli_init(struct parser_state *state);
+extern int cli_init(struct parser_state *state, struct output_ctx *octx);
#else
-static inline int cli_init(struct parser_state *state)
+static inline int cli_init(struct parser_state *state, struct output_ctx *octx)
{
return -1;
}
const char *desc;
const struct datatype *basetype;
const char *basefmt;
- void (*print)(const struct expr *expr);
+ void (*print)(const struct expr *expr,
+ struct output_ctx *octx);
struct error_record *(*parse)(const struct expr *sym,
struct expr **res);
const struct symbol_table *sym_tbl;
extern struct error_record *symbol_parse(const struct expr *sym,
struct expr **res);
-extern void datatype_print(const struct expr *expr);
+extern void datatype_print(const struct expr *expr, struct output_ctx *octx);
static inline bool datatype_equal(const struct datatype *d1,
const struct datatype *d2)
const struct symbol_table *tbl,
struct expr **res);
extern void symbolic_constant_print(const struct symbol_table *tbl,
- const struct expr *expr, bool quotes);
+ const struct expr *expr, bool quotes,
+ struct output_ctx *octx);
extern void symbol_table_print(const struct symbol_table *tbl,
const struct datatype *dtype,
enum byteorder byteorder);
void (*set_type)(const struct expr *expr,
const struct datatype *dtype,
enum byteorder byteorder);
- void (*print)(const struct expr *expr);
+ void (*print)(const struct expr *expr,
+ struct output_ctx *octx);
bool (*cmp)(const struct expr *e1,
const struct expr *e2);
void (*pctx_update)(struct proto_ctx *ctx,
extern struct expr *expr_clone(const struct expr *expr);
extern struct expr *expr_get(struct expr *expr);
extern void expr_free(struct expr *expr);
-extern void expr_print(const struct expr *expr);
+extern void expr_print(const struct expr *expr, struct output_ctx *octx);
extern bool expr_cmp(const struct expr *e1, const struct expr *e2);
extern void expr_describe(const struct expr *expr);
* @set: current set
* @data: pointer to pass data to callback
* @seqnum: sequence number
+ * @octx: output context
*/
struct netlink_ctx {
struct list_head *msgs;
uint32_t seqnum;
struct nftnl_batch *batch;
bool batch_supported;
+ struct output_ctx *octx;
};
extern struct nftnl_table *alloc_nftnl_table(const struct handle *h);
#define INCLUDE_PATHS_MAX 16
+struct output_ctx {
+ unsigned int numeric;
+ unsigned int stateless;
+ unsigned int ip2name;
+ unsigned int handle;
+};
+
extern unsigned int max_errors;
-extern unsigned int numeric_output;
-extern unsigned int stateless_output;
-extern unsigned int ip2name_output;
-extern unsigned int handle_output;
extern unsigned int debug_level;
extern const char *include_paths[INCLUDE_PATHS_MAX];
struct parser_state;
-int nft_run(void *scanner, struct parser_state *state, struct list_head *msgs);
+int nft_run(void *scanner, struct parser_state *state, struct list_head *msgs,
+ struct output_ctx *octx);
#endif /* NFTABLES_NFTABLES_H */
const struct handle *h);
extern struct rule *rule_get(struct rule *rule);
extern void rule_free(struct rule *rule);
-extern void rule_print(const struct rule *rule);
+extern void rule_print(const struct rule *rule, struct output_ctx *octx);
extern struct rule *rule_lookup(const struct chain *chain, uint64_t handle);
/**
extern struct set *set_lookup(const struct table *table, const char *name);
extern struct set *set_lookup_global(uint32_t family, const char *table,
const char *name);
-extern void set_print(const struct set *set);
-extern void set_print_plain(const struct set *s);
+extern void set_print(const struct set *set, struct output_ctx *octx);
+extern void set_print_plain(const struct set *s, struct output_ctx *octx);
#include <statement.h>
void obj_add_hash(struct obj *obj, struct table *table);
struct obj *obj_lookup(const struct table *table, const char *name,
uint32_t type);
-void obj_print(const struct obj *n);
-void obj_print_plain(const struct obj *obj);
+void obj_print(const struct obj *n, struct output_ctx *octx);
+void obj_print_plain(const struct obj *obj, struct output_ctx *octx);
const char *obj_type_name(uint32_t type);
uint32_t obj_type_to_cmd(uint32_t type);
enum stmt_types type;
const char *name;
void (*destroy)(struct stmt *stmt);
- void (*print)(const struct stmt *stmt);
+ void (*print)(const struct stmt *stmt,
+ struct output_ctx *octx);
};
enum stmt_flags {
int stmt_evaluate(struct eval_ctx *ctx, struct stmt *stmt);
extern void stmt_free(struct stmt *stmt);
extern void stmt_list_free(struct list_head *list);
-extern void stmt_print(const struct stmt *stmt);
+extern void stmt_print(const struct stmt *stmt, struct output_ctx *octx);
const char *get_rate(uint64_t byte_rate, uint64_t *rate);
};
static struct parser_state *state;
+static struct output_ctx cli_octx;
static void *scanner;
static char histfile[PATH_MAX];
parser_init(state, &msgs);
scanner_push_buffer(scanner, &indesc_cli, line);
- nft_run(scanner, state, &msgs);
+ nft_run(scanner, state, &msgs, &cli_octx);
erec_print_list(stdout, &msgs);
xfree(line);
cache_release();
rl_forced_update_display();
}
-int cli_init(struct parser_state *_state)
+int cli_init(struct parser_state *_state, struct output_ctx *octx)
{
const char *home;
+ cli_octx = *octx;
rl_readline_name = "nft";
rl_instream = stdin;
rl_outstream = stdout;
#define CT_LABEL_BIT_SIZE 128
-static void ct_label_type_print(const struct expr *expr)
+static void ct_label_type_print(const struct expr *expr,
+ struct output_ctx *octx)
{
unsigned long bit = mpz_scan1(expr->value, 0);
const struct symbolic_constant *s;
printf("%s", ct_templates[key].token);
}
-static void ct_expr_print(const struct expr *expr)
+static void ct_expr_print(const struct expr *expr, struct output_ctx *octx)
{
ct_print(expr->ct.key, expr->ct.direction);
}
}
}
-static void ct_stmt_print(const struct stmt *stmt)
+static void ct_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
ct_print(stmt->ct.key, stmt->ct.direction);
printf(" set ");
- expr_print(stmt->ct.expr);
+ expr_print(stmt->ct.expr, octx);
}
static const struct stmt_ops ct_stmt_ops = {
return stmt;
}
-static void notrack_stmt_print(const struct stmt *stmt)
+static void notrack_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("notrack");
}
return NULL;
}
-void datatype_print(const struct expr *expr)
+void datatype_print(const struct expr *expr, struct output_ctx *octx)
{
const struct datatype *dtype = expr->dtype;
do {
if (dtype->print != NULL)
- return dtype->print(expr);
+ return dtype->print(expr, octx);
if (dtype->sym_tbl != NULL)
return symbolic_constant_print(dtype->sym_tbl, expr,
- false);
+ false, octx);
} while ((dtype = dtype->basetype));
BUG("datatype %s has no print method or symbol table\n",
}
void symbolic_constant_print(const struct symbol_table *tbl,
- const struct expr *expr, bool quotes)
+ const struct expr *expr, bool quotes,
+ struct output_ctx *octx)
{
unsigned int len = div_round_up(expr->len, BITS_PER_BYTE);
const struct symbolic_constant *s;
}
if (s->identifier == NULL)
- return expr_basetype(expr)->print(expr);
+ return expr_basetype(expr)->print(expr, octx);
if (quotes)
printf("\"");
- if (numeric_output > NUMERIC_ALL)
+ if (octx->numeric > NUMERIC_ALL)
printf("%"PRIu64"", val);
else
printf("%s", s->identifier);
}
}
-static void invalid_type_print(const struct expr *expr)
+static void invalid_type_print(const struct expr *expr, struct output_ctx *octx)
{
gmp_printf("0x%Zx [invalid type]", expr->value);
}
.print = invalid_type_print,
};
-static void verdict_type_print(const struct expr *expr)
+static void verdict_type_print(const struct expr *expr, struct output_ctx *octx)
{
switch (expr->verdict) {
case NFT_CONTINUE:
.basetype = &integer_type,
};
-static void integer_type_print(const struct expr *expr)
+static void integer_type_print(const struct expr *expr, struct output_ctx *octx)
{
const struct datatype *dtype = expr->dtype;
const char *fmt = "%Zu";
.parse = integer_type_parse,
};
-static void string_type_print(const struct expr *expr)
+static void string_type_print(const struct expr *expr, struct output_ctx *octx)
{
unsigned int len = div_round_up(expr->len, BITS_PER_BYTE);
char data[len+1];
.parse = string_type_parse,
};
-static void lladdr_type_print(const struct expr *expr)
+static void lladdr_type_print(const struct expr *expr, struct output_ctx *octx)
{
unsigned int len = div_round_up(expr->len, BITS_PER_BYTE);
const char *delim = "";
.parse = lladdr_type_parse,
};
-static void ipaddr_type_print(const struct expr *expr)
+static void ipaddr_type_print(const struct expr *expr, struct output_ctx *octx)
{
struct sockaddr_in sin = { .sin_family = AF_INET, };
char buf[NI_MAXHOST];
sin.sin_addr.s_addr = mpz_get_be32(expr->value);
err = getnameinfo((struct sockaddr *)&sin, sizeof(sin), buf,
sizeof(buf), NULL, 0,
- ip2name_output ? 0 : NI_NUMERICHOST);
+ octx->ip2name ? 0 : NI_NUMERICHOST);
if (err != 0) {
getnameinfo((struct sockaddr *)&sin, sizeof(sin), buf,
sizeof(buf), NULL, 0, NI_NUMERICHOST);
.flags = DTYPE_F_PREFIX,
};
-static void ip6addr_type_print(const struct expr *expr)
+static void ip6addr_type_print(const struct expr *expr, struct output_ctx *octx)
{
struct sockaddr_in6 sin6 = { .sin6_family = AF_INET6 };
char buf[NI_MAXHOST];
err = getnameinfo((struct sockaddr *)&sin6, sizeof(sin6), buf,
sizeof(buf), NULL, 0,
- ip2name_output ? 0 : NI_NUMERICHOST);
+ octx->ip2name ? 0 : NI_NUMERICHOST);
if (err != 0) {
getnameinfo((struct sockaddr *)&sin6, sizeof(sin6), buf,
sizeof(buf), NULL, 0, NI_NUMERICHOST);
.flags = DTYPE_F_PREFIX,
};
-static void inet_protocol_type_print(const struct expr *expr)
+static void inet_protocol_type_print(const struct expr *expr,
+ struct output_ctx *octx)
{
struct protoent *p;
- if (numeric_output < NUMERIC_ALL) {
+ if (octx->numeric < NUMERIC_ALL) {
p = getprotobynumber(mpz_get_uint8(expr->value));
if (p != NULL) {
printf("%s", p->p_name);
return;
}
}
- integer_type_print(expr);
+ integer_type_print(expr, octx);
}
static struct error_record *inet_protocol_type_parse(const struct expr *sym,
.parse = inet_protocol_type_parse,
};
-static void inet_service_type_print(const struct expr *expr)
+static void inet_service_type_print(const struct expr *expr,
+ struct output_ctx *octx)
{
- if (numeric_output >= NUMERIC_PORT) {
- integer_type_print(expr);
+ if (octx->numeric >= NUMERIC_PORT) {
+ integer_type_print(expr, octx);
return;
}
- symbolic_constant_print(&inet_service_tbl, expr, false);
+ symbolic_constant_print(&inet_service_tbl, expr, false, octx);
}
static struct error_record *inet_service_type_parse(const struct expr *sym,
rt_symbol_table_free(mark_tbl);
}
-static void mark_type_print(const struct expr *expr)
+static void mark_type_print(const struct expr *expr, struct output_ctx *octx)
{
- return symbolic_constant_print(mark_tbl, expr, true);
+ return symbolic_constant_print(mark_tbl, expr, true, octx);
}
static struct error_record *mark_type_parse(const struct expr *sym,
}
-static void time_type_print(const struct expr *expr)
+static void time_type_print(const struct expr *expr, struct output_ctx *octx)
{
time_print(mpz_get_uint64(expr->value) / MSEC_PER_SEC);
}
#include <utils.h>
#include <xt.h>
+static struct output_ctx octx_debug_dummy;
static int expr_evaluate(struct eval_ctx *ctx, struct expr **expr);
static const char *byteorder_names[] = {
struct error_record *erec;
erec = erec_create(EREC_INFORMATIONAL, &(*expr)->location,
"Evaluate %s", (*expr)->ops->name);
- erec_print(stdout, erec); expr_print(*expr); printf("\n\n");
+ erec_print(stdout, erec);
+ expr_print(*expr, &octx_debug_dummy);
+ printf("\n\n");
}
#endif
struct error_record *erec;
erec = erec_create(EREC_INFORMATIONAL, &stmt->location,
"Evaluate %s", stmt->ops->name);
- erec_print(stdout, erec); stmt_print(stmt); printf("\n\n");
+ erec_print(stdout, erec); stmt_print(stmt, &octx_debug_dummy);
+ printf("\n\n");
}
#endif
#ifdef DEBUG
if (debug_level & DEBUG_EVALUATION) {
struct error_record *erec;
+
erec = erec_create(EREC_INFORMATIONAL, &cmd->location,
"Evaluate %s", cmd_op_to_name(cmd->op));
erec_print(stdout, erec); printf("\n\n");
xfree(expr);
}
-void expr_print(const struct expr *expr)
+void expr_print(const struct expr *expr, struct output_ctx *octx)
{
- expr->ops->print(expr);
+ expr->ops->print(expr, octx);
}
bool expr_cmp(const struct expr *e1, const struct expr *e2)
return -1;
}
-static void verdict_expr_print(const struct expr *expr)
+static void verdict_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- datatype_print(expr);
+ datatype_print(expr, octx);
}
static bool verdict_expr_cmp(const struct expr *e1, const struct expr *e2)
return expr;
}
-static void symbol_expr_print(const struct expr *expr)
+static void symbol_expr_print(const struct expr *expr, struct output_ctx *octx)
{
printf("%s%s", expr->scope != NULL ? "$" : "", expr->identifier);
}
return expr;
}
-static void constant_expr_print(const struct expr *expr)
+static void constant_expr_print(const struct expr *expr,
+ struct output_ctx *octx)
{
- datatype_print(expr);
+ datatype_print(expr, octx);
}
static bool constant_expr_cmp(const struct expr *e1, const struct expr *e2)
return binop;
}
-static void prefix_expr_print(const struct expr *expr)
+static void prefix_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- expr_print(expr->prefix);
+ expr_print(expr->prefix, octx);
printf("/%u", expr->prefix_len);
}
[OP_LOOKUP] = NULL,
};
-static void unary_expr_print(const struct expr *expr)
+static void unary_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- expr_print(expr->arg);
+ expr_print(expr->arg, octx);
}
static void unary_expr_clone(struct expr *new, const struct expr *expr)
[OP_OR] = 4,
};
-static void binop_arg_print(const struct expr *op, const struct expr *arg)
+static void binop_arg_print(const struct expr *op, const struct expr *arg,
+ struct output_ctx *octx)
{
bool prec = false;
if (prec)
printf("(");
- expr_print(arg);
+ expr_print(arg, octx);
if (prec)
printf(")");
}
return expr->left->ops->type == EXPR_BINOP;
}
-static void binop_expr_print(const struct expr *expr)
+static void binop_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- binop_arg_print(expr, expr->left);
+ binop_arg_print(expr, expr->left, octx);
if (expr_op_symbols[expr->op] &&
(expr->op != OP_EQ || must_print_eq_op(expr)))
else
printf(" ");
- binop_arg_print(expr, expr->right);
+ binop_arg_print(expr, expr->right, octx);
}
static void binop_expr_clone(struct expr *new, const struct expr *expr)
return expr;
}
-static void range_expr_print(const struct expr *expr)
+static void range_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- numeric_output += NUMERIC_ALL + 1;
- expr_print(expr->left);
+ octx->numeric += NUMERIC_ALL + 1;
+ expr_print(expr->left, octx);
printf("-");
- expr_print(expr->right);
- numeric_output -= NUMERIC_ALL + 1;
+ expr_print(expr->right, octx);
+ octx->numeric -= NUMERIC_ALL + 1;
}
static void range_expr_clone(struct expr *new, const struct expr *expr)
expr_free(i);
}
-static void compound_expr_print(const struct expr *expr, const char *delim)
+static void compound_expr_print(const struct expr *expr, const char *delim,
+ struct output_ctx *octx)
{
const struct expr *i;
const char *d = "";
list_for_each_entry(i, &expr->expressions, list) {
printf("%s", d);
- expr_print(i);
+ expr_print(i, octx);
d = delim;
}
}
compound_expr_destroy(expr);
}
-static void concat_expr_print(const struct expr *expr)
+static void concat_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- compound_expr_print(expr, " . ");
+ compound_expr_print(expr, " . ", octx);
}
static const struct expr_ops concat_expr_ops = {
return compound_expr_alloc(loc, &concat_expr_ops);
}
-static void list_expr_print(const struct expr *expr)
+static void list_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- compound_expr_print(expr, ",");
+ compound_expr_print(expr, ",", octx);
}
static const struct expr_ops list_expr_ops = {
return newline;
}
-static void set_expr_print(const struct expr *expr)
+static void set_expr_print(const struct expr *expr, struct output_ctx *octx)
{
const struct expr *i;
const char *d = "";
list_for_each_entry(i, &expr->expressions, list) {
printf("%s", d);
- expr_print(i);
+ expr_print(i, octx);
count++;
d = calculate_delim(expr, &count);
}
return compound_expr_alloc(loc, &set_expr_ops);
}
-static void mapping_expr_print(const struct expr *expr)
+static void mapping_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- expr_print(expr->left);
+ expr_print(expr->left, octx);
printf(" : ");
- expr_print(expr->right);
+ expr_print(expr->right, octx);
}
static void mapping_expr_set_type(const struct expr *expr,
return expr;
}
-static void map_expr_print(const struct expr *expr)
+static void map_expr_print(const struct expr *expr, struct output_ctx *octx)
{
- expr_print(expr->map);
+ expr_print(expr->map, octx);
if (expr->mappings->ops->type == EXPR_SET_REF &&
expr->mappings->set->datatype->type == TYPE_VERDICT)
printf(" vmap ");
else
printf(" map ");
- expr_print(expr->mappings);
+ expr_print(expr->mappings, octx);
}
static void map_expr_clone(struct expr *new, const struct expr *expr)
return expr;
}
-static void set_ref_expr_print(const struct expr *expr)
+static void set_ref_expr_print(const struct expr *expr, struct output_ctx *octx)
{
if (expr->set->flags & NFT_SET_ANONYMOUS) {
if (expr->set->flags & NFT_SET_EVAL)
printf("table %s", expr->set->handle.set);
else
- expr_print(expr->set->init);
+ expr_print(expr->set->init, octx);
} else {
printf("@%s", expr->set->handle.set);
}
return expr;
}
-static void set_elem_expr_print(const struct expr *expr)
+static void set_elem_expr_print(const struct expr *expr,
+ struct output_ctx *octx)
{
- expr_print(expr->key);
+ expr_print(expr->key, octx);
if (expr->timeout) {
printf(" timeout ");
time_print(expr->timeout / 1000);
}
- if (!stateless_output && expr->expiration) {
+ if (!octx->stateless && expr->expiration) {
printf(" expires ");
time_print(expr->expiration / 1000);
}
if (expr->stmt) {
printf(" : ");
- stmt_print(expr->stmt);
+ stmt_print(expr->stmt, octx);
}
}
#include <headers.h>
#include <expression.h>
-static void exthdr_expr_print(const struct expr *expr)
+static void exthdr_expr_print(const struct expr *expr, struct output_ctx *octx)
{
if (expr->exthdr.op == NFT_EXTHDR_OP_TCPOPT) {
/* Offset calcualtion is a bit hacky at this point.
printf(" . ");
}
-static void fib_expr_print(const struct expr *expr)
+static void fib_expr_print(const struct expr *expr, struct output_ctx *octx)
{
unsigned int flags = expr->fib.flags & ~NFTA_FIB_F_PRESENT;
#include <hash.h>
#include <utils.h>
-static void hash_expr_print(const struct expr *expr)
+static void hash_expr_print(const struct expr *expr, struct output_ctx *octx)
{
switch (expr->hash.type) {
case NFT_HASH_SYM:
case NFT_HASH_JENKINS:
default:
printf("jhash ");
- expr_print(expr->hash.expr);
+ expr_print(expr->hash.expr, octx);
}
printf(" mod %u", expr->hash.mod);
#include <iface.h>
#include <cli.h>
+static struct output_ctx octx;
unsigned int max_errors = 10;
-unsigned int numeric_output;
-unsigned int stateless_output;
-unsigned int ip2name_output;
-unsigned int handle_output;
#ifdef DEBUG
unsigned int debug_level;
#endif
.name = "<cmdline>",
};
-static int nft_netlink(struct parser_state *state, struct list_head *msgs)
+static int nft_netlink(struct parser_state *state, struct list_head *msgs,
+ struct output_ctx *octx)
{
struct nftnl_batch *batch;
struct netlink_ctx ctx;
ctx.seqnum = cmd->seqnum = mnl_seqnum_alloc();
ctx.batch = batch;
ctx.batch_supported = batch_supported;
+ ctx.octx = octx;
init_list_head(&ctx.list);
ret = do_command(&ctx, cmd);
if (ret < 0)
return ret;
}
-int nft_run(void *scanner, struct parser_state *state, struct list_head *msgs)
+int nft_run(void *scanner, struct parser_state *state, struct list_head *msgs,
+ struct output_ctx *octx)
{
struct cmd *cmd, *next;
int ret;
list_for_each_entry(cmd, &state->cmds, list)
nft_cmd_expand(cmd);
- ret = nft_netlink(state, msgs);
+ ret = nft_netlink(state, msgs, octx);
err1:
list_for_each_entry_safe(cmd, next, &state->cmds, list) {
list_del(&cmd->list);
include_paths[num_include_paths++] = optarg;
break;
case OPT_NUMERIC:
- if (++numeric_output > NUMERIC_ALL) {
+ if (++octx.numeric > NUMERIC_ALL) {
fprintf(stderr, "Too many numeric options "
"used, max. %u\n",
NUMERIC_ALL);
}
break;
case OPT_STATELESS:
- stateless_output++;
+ octx.stateless++;
break;
case OPT_IP2NAME:
- ip2name_output++;
+ octx.ip2name++;
break;
#ifdef DEBUG
case OPT_DEBUG:
break;
#endif
case OPT_HANDLE_OUTPUT:
- handle_output++;
+ octx.handle++;
break;
case OPT_INVALID:
exit(NFT_EXIT_FAILURE);
if (scanner_read_file(scanner, filename, &internal_location) < 0)
goto out;
} else if (interactive) {
- if (cli_init(&state) < 0) {
+ if (cli_init(&state, &octx) < 0) {
fprintf(stderr, "%s: interactive CLI not supported in this build\n",
argv[0]);
exit(NFT_EXIT_FAILURE);
exit(NFT_EXIT_FAILURE);
}
- if (nft_run(scanner, &state, &msgs) != 0)
+ if (nft_run(scanner, &state, &msgs, &octx) != 0)
rc = NFT_EXIT_FAILURE;
out:
scanner_destroy(scanner);
rt_symbol_table_free(realm_tbl);
}
-static void realm_type_print(const struct expr *expr)
+static void realm_type_print(const struct expr *expr, struct output_ctx *octx)
{
- return symbolic_constant_print(realm_tbl, expr, true);
+ return symbolic_constant_print(realm_tbl, expr, true, octx);
}
static struct error_record *realm_type_parse(const struct expr *sym,
.flags = DTYPE_F_PREFIX,
};
-static void tchandle_type_print(const struct expr *expr)
+static void tchandle_type_print(const struct expr *expr,
+ struct output_ctx *octx)
{
uint32_t handle = mpz_get_uint32(expr->value);
.parse = tchandle_type_parse,
};
-static void ifindex_type_print(const struct expr *expr)
+static void ifindex_type_print(const struct expr *expr, struct output_ctx *octx)
{
char name[IFNAMSIZ];
int ifindex;
.sym_tbl = &arphrd_tbl,
};
-static void uid_type_print(const struct expr *expr)
+static void uid_type_print(const struct expr *expr, struct output_ctx *octx)
{
struct passwd *pw;
- if (numeric_output < NUMERIC_ALL) {
+ if (octx->numeric < NUMERIC_ALL) {
uint32_t uid = mpz_get_uint32(expr->value);
pw = getpwuid(uid);
printf("%d", uid);
return;
}
- expr_basetype(expr)->print(expr);
+ expr_basetype(expr)->print(expr, octx);
}
static struct error_record *uid_type_parse(const struct expr *sym,
.parse = uid_type_parse,
};
-static void gid_type_print(const struct expr *expr)
+static void gid_type_print(const struct expr *expr, struct output_ctx *octx)
{
struct group *gr;
- if (numeric_output < NUMERIC_ALL) {
+ if (octx->numeric < NUMERIC_ALL) {
uint32_t gid = mpz_get_uint32(expr->value);
gr = getgrgid(gid);
printf("%u", gid);
return;
}
- expr_basetype(expr)->print(expr);
+ expr_basetype(expr)->print(expr, octx);
}
static struct error_record *gid_type_parse(const struct expr *sym,
},
};
-static void pkttype_type_print(const struct expr *expr)
+static void pkttype_type_print(const struct expr *expr, struct output_ctx *octx)
{
- return symbolic_constant_print(&pkttype_type_tbl, expr, false);
+ return symbolic_constant_print(&pkttype_type_tbl, expr, false, octx);
}
static const struct datatype pkttype_type = {
rt_symbol_table_free(devgroup_tbl);
}
-static void devgroup_type_print(const struct expr *expr)
+static void devgroup_type_print(const struct expr *expr,
+ struct output_ctx *octx)
{
- return symbolic_constant_print(devgroup_tbl, expr, true);
+ return symbolic_constant_print(devgroup_tbl, expr, true, octx);
}
static struct error_record *devgroup_type_parse(const struct expr *sym,
}
}
-static void meta_expr_print(const struct expr *expr)
+static void meta_expr_print(const struct expr *expr, struct output_ctx *octx)
{
if (meta_key_is_qualified(expr->meta.key))
printf("meta %s", meta_templates[expr->meta.key].token);
return expr;
}
-static void meta_stmt_print(const struct stmt *stmt)
+static void meta_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
if (meta_key_is_qualified(stmt->meta.key))
printf("meta %s set ", meta_templates[stmt->meta.key].token);
else
printf("%s set ", meta_templates[stmt->meta.key].token);
- expr_print(stmt->meta.expr);
+ expr_print(stmt->meta.expr, octx);
}
static const struct stmt_ops meta_stmt_ops = {
nftnl_set_free(nls);
return MNL_CB_ERROR;
}
- set_print_plain(set);
+ set_print_plain(set, monh->ctx->octx);
set_free(set);
printf("\n");
break;
goto out;
}
printf("element %s %s %s ", family2str(family), table, setname);
- expr_print(dummyset->init);
+ expr_print(dummyset->init, monh->ctx->octx);
printf("\n");
set_free(dummyset);
nftnl_obj_free(nlo);
return MNL_CB_ERROR;
}
- obj_print_plain(obj);
+ obj_print_plain(obj, monh->ctx->octx);
obj_free(obj);
printf("\n");
break;
nlr_for_each_set(nlr, rule_map_decompose_cb, NULL);
printf("add rule %s %s %s ", family, table, chain);
- rule_print(r);
+ rule_print(r, monh->ctx->octx);
printf("\n");
rule_free(r);
}
static void trace_print_expr(const struct nftnl_trace *nlt, unsigned int attr,
- struct expr *lhs)
+ struct expr *lhs, struct output_ctx *octx)
{
struct expr *rhs, *rel;
const void *data;
len * BITS_PER_BYTE, data);
rel = relational_expr_alloc(&netlink_location, OP_EQ, lhs, rhs);
- expr_print(rel);
+ expr_print(rel, octx);
printf(" ");
expr_free(rel);
}
-static void trace_print_verdict(const struct nftnl_trace *nlt)
+static void trace_print_verdict(const struct nftnl_trace *nlt,
+ struct output_ctx *octx)
{
const char *chain = NULL;
unsigned int verdict;
expr = verdict_expr_alloc(&netlink_location, verdict, chain);
printf("verdict ");
- expr_print(expr);
+ expr_print(expr, octx);
expr_free(expr);
}
-static void trace_print_rule(const struct nftnl_trace *nlt)
+static void trace_print_rule(const struct nftnl_trace *nlt,
+ struct output_ctx *octx)
{
const struct table *table;
uint64_t rule_handle;
trace_print_hdr(nlt);
printf("rule ");
- rule_print(rule);
+ rule_print(rule, octx);
printf(" (");
- trace_print_verdict(nlt);
+ trace_print_verdict(nlt, octx);
printf(")\n");
}
}
}
-static void trace_print_packet(const struct nftnl_trace *nlt)
+static void trace_print_packet(const struct nftnl_trace *nlt,
+ struct output_ctx *octx)
{
struct list_head stmts = LIST_HEAD_INIT(stmts);
const struct proto_desc *ll_desc;
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_IIF))
trace_print_expr(nlt, NFTNL_TRACE_IIF,
meta_expr_alloc(&netlink_location,
- NFT_META_IIF));
+ NFT_META_IIF), octx);
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_OIF))
trace_print_expr(nlt, NFTNL_TRACE_OIF,
meta_expr_alloc(&netlink_location,
- NFT_META_OIF));
+ NFT_META_OIF), octx);
proto_ctx_init(&ctx, nftnl_trace_get_u32(nlt, NFTNL_TRACE_FAMILY));
ll_desc = ctx.protocol[PROTO_BASE_LL_HDR].desc;
PROTO_BASE_TRANSPORT_HDR);
list_for_each_entry_safe(stmt, next, &stmts, list) {
- stmt_print(stmt);
+ stmt_print(stmt, octx);
printf(" ");
stmt_free(stmt);
}
case NFT_TRACETYPE_RULE:
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_LL_HEADER) ||
nftnl_trace_is_set(nlt, NFTNL_TRACE_NETWORK_HEADER))
- trace_print_packet(nlt);
+ trace_print_packet(nlt, monh->ctx->octx);
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_RULE_HANDLE))
- trace_print_rule(nlt);
+ trace_print_rule(nlt, monh->ctx->octx);
break;
case NFT_TRACETYPE_POLICY:
case NFT_TRACETYPE_RETURN:
trace_print_hdr(nlt);
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_VERDICT)) {
- trace_print_verdict(nlt);
+ trace_print_verdict(nlt, monh->ctx->octx);
printf(" ");
}
if (nftnl_trace_is_set(nlt, NFTNL_TRACE_MARK))
trace_print_expr(nlt, NFTNL_TRACE_MARK,
meta_expr_alloc(&netlink_location,
- NFT_META_MARK));
+ NFT_META_MARK),
+ monh->ctx->octx);
printf("\n");
break;
}
return numgen_type[type];
}
-static void numgen_expr_print(const struct expr *expr)
+static void numgen_expr_print(const struct expr *expr, struct output_ctx *octx)
{
printf("numgen %s mod %u", numgen_type_str(expr->numgen.type),
expr->numgen.mod);
tmpl != &proto_unknown_template;
}
-static void payload_expr_print(const struct expr *expr)
+static void payload_expr_print(const struct expr *expr, struct output_ctx *octx)
{
const struct proto_desc *desc;
const struct proto_hdr_template *tmpl;
return expr->payload.tmpl - expr->payload.desc->templates;
}
-static void payload_stmt_print(const struct stmt *stmt)
+static void payload_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
- expr_print(stmt->payload.expr);
+ expr_print(stmt->payload.expr, octx);
printf(" set ");
- expr_print(stmt->payload.val);
+ expr_print(stmt->payload.val, octx);
}
static const struct stmt_ops payload_stmt_ops = {
},
};
-static void ethertype_print(const struct expr *expr)
+static void ethertype_print(const struct expr *expr, struct output_ctx *octx)
{
- return symbolic_constant_print(ðertype_tbl, expr, false);
+ return symbolic_constant_print(ðertype_tbl, expr, false, octx);
}
const struct datatype ethertype_type = {
rt_symbol_table_free(realm_tbl);
}
-static void realm_type_print(const struct expr *expr)
+static void realm_type_print(const struct expr *expr, struct output_ctx *octx)
{
- return symbolic_constant_print(realm_tbl, expr, true);
+ return symbolic_constant_print(realm_tbl, expr, true, octx);
}
static struct error_record *realm_type_parse(const struct expr *sym,
true),
};
-static void rt_expr_print(const struct expr *expr)
+static void rt_expr_print(const struct expr *expr, struct output_ctx *octx)
{
printf("rt %s", rt_templates[expr->rt.key].token);
}
}
}
-static void do_set_print(const struct set *set, struct print_fmt_options *opts)
+static void do_set_print(const struct set *set, struct print_fmt_options *opts,
+ struct output_ctx *octx)
{
set_print_declaration(set, opts);
if (set->init != NULL && set->init->size > 0) {
printf("%s%selements = ", opts->tab, opts->tab);
- expr_print(set->init);
+ expr_print(set->init, octx);
printf("%s", opts->nl);
}
printf("%s}%s", opts->tab, opts->nl);
}
-void set_print(const struct set *s)
+void set_print(const struct set *s, struct output_ctx *octx)
{
struct print_fmt_options opts = {
.tab = "\t",
.stmt_separator = "\n",
};
- do_set_print(s, &opts);
+ do_set_print(s, &opts, octx);
}
-void set_print_plain(const struct set *s)
+void set_print_plain(const struct set *s, struct output_ctx *octx)
{
struct print_fmt_options opts = {
.tab = "",
.stmt_separator = ";",
};
- do_set_print(s, &opts);
+ do_set_print(s, &opts, octx);
}
struct rule *rule_alloc(const struct location *loc, const struct handle *h)
xfree(rule);
}
-void rule_print(const struct rule *rule)
+void rule_print(const struct rule *rule, struct output_ctx *octx)
{
const struct stmt *stmt;
list_for_each_entry(stmt, &rule->stmts, list) {
- stmt->ops->print(stmt);
+ stmt->ops->print(stmt, octx);
if (!list_is_last(&stmt->list, &rule->stmts))
printf(" ");
}
if (rule->comment)
printf(" comment \"%s\"", rule->comment);
- if (handle_output > 0)
+ if (octx->handle > 0)
printf(" # handle %" PRIu64, rule->handle.handle.id);
}
}
}
-static void chain_print(const struct chain *chain)
+static void chain_print(const struct chain *chain, struct output_ctx *octx)
{
struct rule *rule;
list_for_each_entry(rule, &chain->rules, list) {
printf("\t\t");
- rule_print(rule);
+ rule_print(rule, octx);
printf("\n");
}
printf("\t}\n");
}
}
-static void table_print(const struct table *table)
+static void table_print(const struct table *table, struct output_ctx *octx)
{
struct chain *chain;
struct obj *obj;
list_for_each_entry(obj, &table->objs, list) {
printf("%s", delim);
- obj_print(obj);
+ obj_print(obj, octx);
delim = "\n";
}
list_for_each_entry(set, &table->sets, list) {
if (set->flags & NFT_SET_ANONYMOUS)
continue;
printf("%s", delim);
- set_print(set);
+ set_print(set, octx);
delim = "\n";
}
list_for_each_entry(chain, &table->chains, list) {
printf("%s", delim);
- chain_print(chain);
+ chain_print(chain, octx);
delim = "\n";
}
printf("}\n");
static int do_list_table(struct netlink_ctx *ctx, struct cmd *cmd,
struct table *table)
{
- table_print(table);
+ table_print(table, ctx->octx);
return 0;
}
}
static void obj_print_data(const struct obj *obj,
- struct print_fmt_options *opts)
+ struct print_fmt_options *opts,
+ struct output_ctx *octx)
{
switch (obj->type) {
case NFT_OBJECT_COUNTER:
printf(" %s {%s%s%s", obj->handle.obj,
opts->nl, opts->tab, opts->tab);
- if (stateless_output) {
+ if (octx->stateless) {
printf("packets 0 bytes 0");
break;
}
printf("%s%"PRIu64" %s",
obj->quota.flags & NFT_QUOTA_F_INV ? "over " : "",
bytes, data_unit);
- if (!stateless_output && obj->quota.used) {
+ if (!octx->stateless && obj->quota.used) {
data_unit = get_rate(obj->quota.used, &bytes);
printf(" used %"PRIu64" %s", bytes, data_unit);
}
}
static void obj_print_declaration(const struct obj *obj,
- struct print_fmt_options *opts)
+ struct print_fmt_options *opts,
+ struct output_ctx *octx)
{
printf("%s%s", opts->tab, obj_type_name(obj->type));
if (opts->table != NULL)
printf(" %s", opts->table);
- obj_print_data(obj, opts);
+ obj_print_data(obj, opts, octx);
printf("%s%s}%s", opts->nl, opts->tab, opts->nl);
}
-void obj_print(const struct obj *obj)
+void obj_print(const struct obj *obj, struct output_ctx *octx)
{
struct print_fmt_options opts = {
.tab = "\t",
.stmt_separator = "\n",
};
- obj_print_declaration(obj, &opts);
+ obj_print_declaration(obj, &opts, octx);
}
-void obj_print_plain(const struct obj *obj)
+void obj_print_plain(const struct obj *obj, struct output_ctx *octx)
{
struct print_fmt_options opts = {
.tab = "",
.family = family2str(obj->handle.family),
};
- obj_print_declaration(obj, &opts);
+ obj_print_declaration(obj, &opts, octx);
}
static int do_list_obj(struct netlink_ctx *ctx, struct cmd *cmd, uint32_t type)
strcmp(cmd->handle.obj, obj->handle.obj)))
continue;
- obj_print_declaration(obj, &opts);
+ obj_print_declaration(obj, &opts, ctx->octx);
}
printf("}\n");
strcmp(cmd->handle.chain, chain->handle.chain) != 0)
continue;
- chain_print(chain);
+ chain_print(chain, ctx->octx);
}
printf("}\n");
return -1;
table_print_declaration(table);
- set_print(set);
+ set_print(set, ctx->octx);
printf("}\n");
return 0;
struct expr *expr;
};
+static struct output_ctx debug_octx = {};
+
static void seg_tree_init(struct seg_tree *tree, const struct set *set,
struct expr *init)
{
}
if (segtree_debug()) {
- expr_print(init);
+ expr_print(init, &debug_octx);
pr_gmp_debug("\n");
}
}
}
-void stmt_print(const struct stmt *stmt)
+void stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
- stmt->ops->print(stmt);
+ stmt->ops->print(stmt, octx);
}
-static void expr_stmt_print(const struct stmt *stmt)
+static void expr_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
- expr_print(stmt->expr);
+ expr_print(stmt->expr, octx);
}
static void expr_stmt_destroy(struct stmt *stmt)
return stmt;
}
-static void flow_stmt_print(const struct stmt *stmt)
+static void flow_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("flow ");
if (stmt->flow.set) {
- expr_print(stmt->flow.set);
+ expr_print(stmt->flow.set, octx);
printf(" ");
}
printf("{ ");
- expr_print(stmt->flow.key);
+ expr_print(stmt->flow.key, octx);
printf(" ");
- stateless_output++;
- stmt_print(stmt->flow.stmt);
- stateless_output--;
+ octx->stateless++;
+ stmt_print(stmt->flow.stmt, octx);
+ octx->stateless--;
printf("} ");
return stmt_alloc(loc, &flow_stmt_ops);
}
-static void counter_stmt_print(const struct stmt *stmt)
+static void counter_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("counter");
- if (stateless_output)
+ if (octx->stateless)
return;
printf(" packets %" PRIu64 " bytes %" PRIu64,
return objref_type[type];
}
-static void objref_stmt_print(const struct stmt *stmt)
+static void objref_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
switch (stmt->objref.type) {
case NFT_OBJECT_CT_HELPER:
printf("%s name ", objref_type_name(stmt->objref.type));
break;
}
- expr_print(stmt->objref.expr);
+ expr_print(stmt->objref.expr, octx);
}
static const struct stmt_ops objref_stmt_ops = {
return syslog_level[level];
}
-static void log_stmt_print(const struct stmt *stmt)
+static void log_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("log");
if (stmt->log.flags & STMT_LOG_PREFIX)
return data_unit[i];
}
-static void limit_stmt_print(const struct stmt *stmt)
+static void limit_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
bool inv = stmt->limit.flags & NFT_LIMIT_F_INV;
const char *data_unit;
return stmt;
}
-static void queue_stmt_print(const struct stmt *stmt)
+static void queue_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
const char *delim = " ";
printf("queue");
if (stmt->queue.queue != NULL) {
printf(" num ");
- expr_print(stmt->queue.queue);
+ expr_print(stmt->queue.queue, octx);
}
if (stmt->queue.flags & NFT_QUEUE_FLAG_BYPASS) {
printf("%sbypass", delim);
return stmt_alloc(loc, &queue_stmt_ops);
}
-static void quota_stmt_print(const struct stmt *stmt)
+static void quota_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
bool inv = stmt->quota.flags & NFT_QUOTA_F_INV;
const char *data_unit;
printf("quota %s%"PRIu64" %s",
inv ? "over " : "", bytes, data_unit);
- if (!stateless_output && stmt->quota.used) {
+ if (!octx->stateless && stmt->quota.used) {
data_unit = get_rate(stmt->quota.used, &used);
printf(" used %"PRIu64" %s", used, data_unit);
}
return stmt;
}
-static void reject_stmt_print(const struct stmt *stmt)
+static void reject_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("reject");
switch (stmt->reject.type) {
if (stmt->reject.icmp_code == NFT_REJECT_ICMPX_PORT_UNREACH)
break;
printf(" with icmpx type ");
- expr_print(stmt->reject.expr);
+ expr_print(stmt->reject.expr, octx);
break;
case NFT_REJECT_ICMP_UNREACH:
switch (stmt->reject.family) {
if (stmt->reject.icmp_code == ICMP_PORT_UNREACH)
break;
printf(" with icmp type ");
- expr_print(stmt->reject.expr);
+ expr_print(stmt->reject.expr, octx);
break;
case NFPROTO_IPV6:
if (stmt->reject.icmp_code == ICMP6_DST_UNREACH_NOPORT)
break;
printf(" with icmpv6 type ");
- expr_print(stmt->reject.expr);
+ expr_print(stmt->reject.expr, octx);
break;
}
break;
printf("%spersistent", delim);
}
-static void nat_stmt_print(const struct stmt *stmt)
+static void nat_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
static const char *nat_types[] = {
[NFT_NAT_SNAT] = "snat",
if (stmt->nat.addr->ops->type == EXPR_VALUE &&
stmt->nat.addr->dtype->type == TYPE_IP6ADDR) {
printf("[");
- expr_print(stmt->nat.addr);
+ expr_print(stmt->nat.addr, octx);
printf("]");
} else if (stmt->nat.addr->ops->type == EXPR_RANGE &&
stmt->nat.addr->left->dtype->type == TYPE_IP6ADDR) {
printf("[");
- expr_print(stmt->nat.addr->left);
+ expr_print(stmt->nat.addr->left, octx);
printf("]-[");
- expr_print(stmt->nat.addr->right);
+ expr_print(stmt->nat.addr->right, octx);
printf("]");
} else {
- expr_print(stmt->nat.addr);
+ expr_print(stmt->nat.addr, octx);
}
} else {
- expr_print(stmt->nat.addr);
+ expr_print(stmt->nat.addr, octx);
}
}
if (stmt->nat.proto) {
printf(":");
- expr_print(stmt->nat.proto);
+ expr_print(stmt->nat.proto, octx);
}
print_nf_nat_flags(stmt->nat.flags);
return stmt_alloc(loc, &nat_stmt_ops);
}
-static void masq_stmt_print(const struct stmt *stmt)
+static void masq_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("masquerade");
if (stmt->masq.proto) {
printf(" to :");
- expr_print(stmt->masq.proto);
+ expr_print(stmt->masq.proto, octx);
}
print_nf_nat_flags(stmt->masq.flags);
return stmt_alloc(loc, &masq_stmt_ops);
}
-static void redir_stmt_print(const struct stmt *stmt)
+static void redir_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("redirect");
if (stmt->redir.proto) {
printf(" to :");
- expr_print(stmt->redir.proto);
+ expr_print(stmt->redir.proto, octx);
}
print_nf_nat_flags(stmt->redir.flags);
[NFT_DYNSET_OP_UPDATE] = "update",
};
-static void set_stmt_print(const struct stmt *stmt)
+static void set_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("set %s ", set_stmt_op_names[stmt->set.op]);
- expr_print(stmt->set.key);
+ expr_print(stmt->set.key, octx);
printf(" ");
- expr_print(stmt->set.set);
+ expr_print(stmt->set.set, octx);
}
static void set_stmt_destroy(struct stmt *stmt)
return stmt_alloc(loc, &set_stmt_ops);
}
-static void dup_stmt_print(const struct stmt *stmt)
+static void dup_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("dup");
if (stmt->dup.to != NULL) {
printf(" to ");
- expr_print(stmt->dup.to);
+ expr_print(stmt->dup.to, octx);
if (stmt->dup.dev != NULL) {
printf(" device ");
- expr_print(stmt->dup.dev);
+ expr_print(stmt->dup.dev, octx);
}
}
}
return stmt_alloc(loc, &dup_stmt_ops);
}
-static void fwd_stmt_print(const struct stmt *stmt)
+static void fwd_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
printf("fwd to ");
- expr_print(stmt->fwd.to);
+ expr_print(stmt->fwd.to, octx);
}
static void fwd_stmt_destroy(struct stmt *stmt)
return stmt_alloc(loc, &fwd_stmt_ops);
}
-static void xt_stmt_print(const struct stmt *stmt)
+static void xt_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
{
xt_stmt_xlate(stmt);
}
projects / thirdparty / nftables.git / commitdiff
