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 
32 static 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 
40 static int
41 nftnl_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 
68 static const void *
69 nftnl_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 
90 static void
91 nftnl_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 
110 static 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 
137 static int
138 nftnl_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 
179 static int
180 nftnl_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 
204 struct 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 };