libnftnl 1.2.6
inner.c
1/*
2 * (C) 2012-2022 by Pablo Neira Ayuso <pablo@netfilter.org>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published
6 * by the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10#include "internal.h"
11
12#include <stdio.h>
13#include <stdint.h>
14#include <string.h>
15#include <limits.h>
16#include <arpa/inet.h>
17#include <errno.h>
18#include <libmnl/libmnl.h>
19
20#include <linux/netfilter/nf_tables.h>
21
22#include <libnftnl/expr.h>
23#include <libnftnl/rule.h>
24
26 uint32_t type;
27 uint32_t flags;
28 uint32_t hdrsize;
29 struct nftnl_expr *expr;
30};
31
32static void nftnl_expr_inner_free(const struct nftnl_expr *e)
33{
34 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
35
36 if (inner->expr)
37 nftnl_expr_free(inner->expr);
38}
39
40static int
41nftnl_expr_inner_set(struct nftnl_expr *e, uint16_t type,
42 const void *data, uint32_t data_len)
43{
44 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
45
46 switch(type) {
47 case NFTNL_EXPR_INNER_TYPE:
48 memcpy(&inner->type, data, sizeof(inner->type));
49 break;
50 case NFTNL_EXPR_INNER_FLAGS:
51 memcpy(&inner->flags, data, sizeof(inner->flags));
52 break;
53 case NFTNL_EXPR_INNER_HDRSIZE:
54 memcpy(&inner->hdrsize, data, sizeof(inner->hdrsize));
55 break;
56 case NFTNL_EXPR_INNER_EXPR:
57 if (inner->expr)
58 nftnl_expr_free(inner->expr);
59
60 inner->expr = (void *)data;
61 break;
62 default:
63 return -1;
64 }
65 return 0;
66}
67
68static const void *
69nftnl_expr_inner_get(const struct nftnl_expr *e, uint16_t type,
70 uint32_t *data_len)
71{
72 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
73
74 switch(type) {
75 case NFTNL_EXPR_INNER_FLAGS:
76 *data_len = sizeof(inner->flags);
77 return &inner->flags;
78 case NFTNL_EXPR_INNER_TYPE:
79 *data_len = sizeof(inner->type);
80 return &inner->type;
81 case NFTNL_EXPR_INNER_HDRSIZE:
82 *data_len = sizeof(inner->hdrsize);
83 return &inner->hdrsize;
84 case NFTNL_EXPR_INNER_EXPR:
85 return inner->expr;
86 }
87 return NULL;
88}
89
90static void
91nftnl_expr_inner_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
92{
93 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
94 struct nlattr *nest;
95
96 mnl_attr_put_u32(nlh, NFTA_INNER_NUM, htonl(0));
97 if (e->flags & (1 << NFTNL_EXPR_INNER_TYPE))
98 mnl_attr_put_u32(nlh, NFTA_INNER_TYPE, htonl(inner->type));
99 if (e->flags & (1 << NFTNL_EXPR_INNER_FLAGS))
100 mnl_attr_put_u32(nlh, NFTA_INNER_FLAGS, htonl(inner->flags));
101 if (e->flags & (1 << NFTNL_EXPR_INNER_HDRSIZE))
102 mnl_attr_put_u32(nlh, NFTA_INNER_HDRSIZE, htonl(inner->hdrsize));
103 if (e->flags & (1 << NFTNL_EXPR_INNER_EXPR)) {
104 nest = mnl_attr_nest_start(nlh, NFTA_INNER_EXPR);
105 nftnl_expr_build_payload(nlh, inner->expr);
106 mnl_attr_nest_end(nlh, nest);
107 }
108}
109
110static int nftnl_inner_parse_cb(const struct nlattr *attr, void *data)
111{
112 const struct nlattr **tb = data;
113 int type = mnl_attr_get_type(attr);
114
115 if (mnl_attr_type_valid(attr, NFTA_INNER_MAX) < 0)
116 return MNL_CB_OK;
117
118 switch(type) {
119 case NFTA_INNER_NUM:
120 case NFTA_INNER_TYPE:
121 case NFTA_INNER_HDRSIZE:
122 case NFTA_INNER_FLAGS:
123 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
124 abi_breakage();
125 break;
126 case NFTA_INNER_EXPR:
127 if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0)
128 abi_breakage();
129 break;
130 }
131
132 tb[type] = attr;
133
134 return MNL_CB_OK;
135}
136
137static int
138nftnl_expr_inner_parse(struct nftnl_expr *e, struct nlattr *attr)
139{
140 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
141 struct nlattr *tb[NFTA_INNER_MAX + 1] = {};
142 struct nftnl_expr *expr;
143 int err;
144
145 err = mnl_attr_parse_nested(attr, nftnl_inner_parse_cb, tb);
146 if (err < 0)
147 return err;
148
149 if (tb[NFTA_INNER_HDRSIZE]) {
150 inner->hdrsize =
151 ntohl(mnl_attr_get_u32(tb[NFTA_INNER_HDRSIZE]));
152 e->flags |= (1 << NFTNL_EXPR_INNER_HDRSIZE);
153 }
154 if (tb[NFTA_INNER_FLAGS]) {
155 inner->flags =
156 ntohl(mnl_attr_get_u32(tb[NFTA_INNER_FLAGS]));
157 e->flags |= (1 << NFTNL_EXPR_INNER_FLAGS);
158 }
159 if (tb[NFTA_INNER_TYPE]) {
160 inner->type =
161 ntohl(mnl_attr_get_u32(tb[NFTA_INNER_TYPE]));
162 e->flags |= (1 << NFTNL_EXPR_INNER_TYPE);
163 }
164 if (tb[NFTA_INNER_EXPR]) {
165 expr = nftnl_expr_parse(tb[NFTA_INNER_EXPR]);
166 if (!expr)
167 return -1;
168
169 if (inner->expr)
170 nftnl_expr_free(inner->expr);
171
172 inner->expr = expr;
173 e->flags |= (1 << NFTNL_EXPR_INNER_EXPR);
174 }
175
176 return 0;
177}
178
179static int
180nftnl_expr_inner_snprintf(char *buf, size_t remain, uint32_t flags,
181 const struct nftnl_expr *e)
182{
183 struct nftnl_expr_inner *inner = nftnl_expr_data(e);
184 uint32_t offset = 0;
185 int ret;
186
187 ret = snprintf(buf, remain, "type %u hdrsize %u flags %x [",
188 inner->type, inner->hdrsize, inner->flags);
189 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
190
191 ret = snprintf(buf + offset, remain, " %s ", inner->expr->ops->name);
192 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
193
194 ret = nftnl_expr_snprintf(buf + offset, remain, inner->expr,
195 NFTNL_OUTPUT_DEFAULT, 0);
196 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
197
198 ret = snprintf(buf + offset, remain, "] ");
199 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
200
201 return offset;
202}
203
204struct expr_ops expr_ops_inner = {
205 .name = "inner",
206 .alloc_len = sizeof(struct nftnl_expr_inner),
207 .max_attr = NFTA_INNER_MAX,
208 .free = nftnl_expr_inner_free,
209 .set = nftnl_expr_inner_set,
210 .get = nftnl_expr_inner_get,
211 .parse = nftnl_expr_inner_parse,
212 .build = nftnl_expr_inner_build,
213 .output = nftnl_expr_inner_snprintf,
214};