xtables.h revision cd2f9bdbb7f9b737e5d640aafeb78bcd8e3a7adf 
1#ifndef _XTABLES_H
2#define _XTABLES_H
3
4/*
5 * Changing any structs/functions may incur a needed change
6 * in libxtables_vcurrent/vage too.
7 */
8
9#include <sys/socket.h> /* PF_* */
10#include <sys/types.h>
11#include <limits.h>
12#include <stdbool.h>
13#include <stddef.h>
14#include <stdint.h>
15#include <netinet/in.h>
16#include <net/if.h>
17#include <linux/types.h>
18#include <linux/netfilter.h>
19#include <linux/netfilter/x_tables.h>
20
21#ifndef IPPROTO_SCTP
22#define IPPROTO_SCTP 132
23#endif
24#ifndef IPPROTO_DCCP
25#define IPPROTO_DCCP 33
26#endif
27#ifndef IPPROTO_MH
28#	define IPPROTO_MH 135
29#endif
30#ifndef IPPROTO_UDPLITE
31#define IPPROTO_UDPLITE	136
32#endif
33
34#include <xtables-version.h>
35
36struct in_addr;
37
38/*
39 * .size is here so that there is a somewhat reasonable check
40 * against the chosen .type.
41 */
42#define XTOPT_POINTER(stype, member) \
43	.ptroff = offsetof(stype, member), \
44	.size = sizeof(((stype *)NULL)->member)
45#define XTOPT_TABLEEND {.name = NULL}
46
47/**
48 * Select the format the input has to conform to, as well as the target type
49 * (area pointed to with XTOPT_POINTER). Note that the storing is not always
50 * uniform. @cb->val will be populated with as much as there is space, i.e.
51 * exactly 2 items for ranges, but the target area can receive more values
52 * (e.g. in case of ranges), or less values (e.g. %XTTYPE_HOSTMASK).
53 *
54 * %XTTYPE_NONE:	option takes no argument
55 * %XTTYPE_UINT*:	standard integer
56 * %XTTYPE_UINT*RC:	colon-separated range of standard integers
57 * %XTTYPE_DOUBLE:	double-precision floating point number
58 * %XTTYPE_STRING:	arbitrary string
59 * %XTTYPE_TOSMASK:	8-bit TOS value with optional mask
60 * %XTTYPE_MARKMASK32:	32-bit mark with optional mask
61 * %XTTYPE_SYSLOGLEVEL:	syslog level by name or number
62 * %XTTYPE_HOST:	one host or address (ptr: union nf_inet_addr)
63 * %XTTYPE_HOSTMASK:	one host or address, with an optional prefix length
64 * 			(ptr: union nf_inet_addr; only host portion is stored)
65 * %XTTYPE_PROTOCOL:	protocol number/name from /etc/protocols (ptr: uint8_t)
66 * %XTTYPE_PORT:	16-bit port name or number (supports %XTOPT_NBO)
67 * %XTTYPE_PORTRC:	colon-separated port range (names acceptable),
68 * 			(supports %XTOPT_NBO)
69 * %XTTYPE_PLEN:	prefix length
70 * %XTTYPE_PLENMASK:	prefix length (ptr: union nf_inet_addr)
71 * %XTTYPE_ETHERMAC:	Ethernet MAC address in hex form
72 */
73enum xt_option_type {
74	XTTYPE_NONE,
75	XTTYPE_UINT8,
76	XTTYPE_UINT16,
77	XTTYPE_UINT32,
78	XTTYPE_UINT64,
79	XTTYPE_UINT8RC,
80	XTTYPE_UINT16RC,
81	XTTYPE_UINT32RC,
82	XTTYPE_UINT64RC,
83	XTTYPE_DOUBLE,
84	XTTYPE_STRING,
85	XTTYPE_TOSMASK,
86	XTTYPE_MARKMASK32,
87	XTTYPE_SYSLOGLEVEL,
88	XTTYPE_HOST,
89	XTTYPE_HOSTMASK,
90	XTTYPE_PROTOCOL,
91	XTTYPE_PORT,
92	XTTYPE_PORTRC,
93	XTTYPE_PLEN,
94	XTTYPE_PLENMASK,
95	XTTYPE_ETHERMAC,
96};
97
98/**
99 * %XTOPT_INVERT:	option is invertible (usable with !)
100 * %XTOPT_MAND:		option is mandatory
101 * %XTOPT_MULTI:	option may be specified multiple times
102 * %XTOPT_PUT:		store value into memory at @ptroff
103 * %XTOPT_NBO:		store value in network-byte order
104 * 			(only certain XTTYPEs recognize this)
105 */
106enum xt_option_flags {
107	XTOPT_INVERT = 1 << 0,
108	XTOPT_MAND   = 1 << 1,
109	XTOPT_MULTI  = 1 << 2,
110	XTOPT_PUT    = 1 << 3,
111	XTOPT_NBO    = 1 << 4,
112};
113
114/**
115 * @name:	name of option
116 * @type:	type of input and validation method, see %XTTYPE_*
117 * @id:		unique number (within extension) for option, 0-31
118 * @excl:	bitmask of flags that cannot be used with this option
119 * @also:	bitmask of flags that must be used with this option
120 * @flags:	bitmask of option flags, see %XTOPT_*
121 * @ptroff:	offset into private structure for member
122 * @size:	size of the item pointed to by @ptroff; this is a safeguard
123 * @min:	lowest allowed value (for singular integral types)
124 * @max:	highest allowed value (for singular integral types)
125 */
126struct xt_option_entry {
127	const char *name;
128	enum xt_option_type type;
129	unsigned int id, excl, also, flags;
130	unsigned int ptroff;
131	size_t size;
132	unsigned int min, max;
133};
134
135/**
136 * @arg:	input from command line
137 * @ext_name:	name of extension currently being processed
138 * @entry:	current option being processed
139 * @data:	per-extension kernel data block
140 * @xflags:	options of the extension that have been used
141 * @invert:	whether option was used with !
142 * @nvals:	number of results in uXX_multi
143 * @val:	parsed result
144 * @udata:	per-extension private scratch area
145 * 		(cf. xtables_{match,target}->udata_size)
146 */
147struct xt_option_call {
148	const char *arg, *ext_name;
149	const struct xt_option_entry *entry;
150	void *data;
151	unsigned int xflags;
152	bool invert;
153	uint8_t nvals;
154	union {
155		uint8_t u8, u8_range[2], syslog_level, protocol;
156		uint16_t u16, u16_range[2], port, port_range[2];
157		uint32_t u32, u32_range[2];
158		uint64_t u64, u64_range[2];
159		double dbl;
160		struct {
161			union nf_inet_addr haddr, hmask;
162			uint8_t hlen;
163		};
164		struct {
165			uint8_t tos_value, tos_mask;
166		};
167		struct {
168			uint32_t mark, mask;
169		};
170		uint8_t ethermac[6];
171	} val;
172	/* Wished for a world where the ones below were gone: */
173	union {
174		struct xt_entry_match **match;
175		struct xt_entry_target **target;
176	};
177	void *xt_entry;
178	void *udata;
179};
180
181/**
182 * @ext_name:	name of extension currently being processed
183 * @data:	per-extension (kernel) data block
184 * @udata:	per-extension private scratch area
185 * 		(cf. xtables_{match,target}->udata_size)
186 * @xflags:	options of the extension that have been used
187 */
188struct xt_fcheck_call {
189	const char *ext_name;
190	void *data, *udata;
191	unsigned int xflags;
192};
193
194/**
195 * A "linear"/linked-list based name<->id map, for files similar to
196 * /etc/iproute2/.
197 */
198struct xtables_lmap {
199	char *name;
200	int id;
201	struct xtables_lmap *next;
202};
203
204/* Include file for additions: new matches and targets. */
205struct xtables_match
206{
207	/*
208	 * ABI/API version this module requires. Must be first member,
209	 * as the rest of this struct may be subject to ABI changes.
210	 */
211	const char *version;
212
213	struct xtables_match *next;
214
215	const char *name;
216
217	/* Revision of match (0 by default). */
218	u_int8_t revision;
219
220	u_int16_t family;
221
222	/* Size of match data. */
223	size_t size;
224
225	/* Size of match data relevent for userspace comparison purposes */
226	size_t userspacesize;
227
228	/* Function which prints out usage message. */
229	void (*help)(void);
230
231	/* Initialize the match. */
232	void (*init)(struct xt_entry_match *m);
233
234	/* Function which parses command options; returns true if it
235           ate an option */
236	/* entry is struct ipt_entry for example */
237	int (*parse)(int c, char **argv, int invert, unsigned int *flags,
238		     const void *entry,
239		     struct xt_entry_match **match);
240
241	/* Final check; exit if not ok. */
242	void (*final_check)(unsigned int flags);
243
244	/* Prints out the match iff non-NULL: put space at end */
245	/* ip is struct ipt_ip * for example */
246	void (*print)(const void *ip,
247		      const struct xt_entry_match *match, int numeric);
248
249	/* Saves the match info in parsable form to stdout. */
250	/* ip is struct ipt_ip * for example */
251	void (*save)(const void *ip, const struct xt_entry_match *match);
252
253	/* Pointer to list of extra command-line options */
254	const struct option *extra_opts;
255
256	/* New parser */
257	void (*x6_parse)(struct xt_option_call *);
258	void (*x6_fcheck)(struct xt_fcheck_call *);
259	const struct xt_option_entry *x6_options;
260
261	/* Size of per-extension instance extra "global" scratch space */
262	size_t udata_size;
263
264	/* Ignore these men behind the curtain: */
265	void *udata;
266	unsigned int option_offset;
267	struct xt_entry_match *m;
268	unsigned int mflags;
269	unsigned int loaded; /* simulate loading so options are merged properly */
270};
271
272struct xtables_target
273{
274	/*
275	 * ABI/API version this module requires. Must be first member,
276	 * as the rest of this struct may be subject to ABI changes.
277	 */
278	const char *version;
279
280	struct xtables_target *next;
281
282
283	const char *name;
284
285	/* Real target behind this, if any. */
286	const char *real_name;
287
288	/* Revision of target (0 by default). */
289	u_int8_t revision;
290
291	u_int16_t family;
292
293
294	/* Size of target data. */
295	size_t size;
296
297	/* Size of target data relevent for userspace comparison purposes */
298	size_t userspacesize;
299
300	/* Function which prints out usage message. */
301	void (*help)(void);
302
303	/* Initialize the target. */
304	void (*init)(struct xt_entry_target *t);
305
306	/* Function which parses command options; returns true if it
307           ate an option */
308	/* entry is struct ipt_entry for example */
309	int (*parse)(int c, char **argv, int invert, unsigned int *flags,
310		     const void *entry,
311		     struct xt_entry_target **targetinfo);
312
313	/* Final check; exit if not ok. */
314	void (*final_check)(unsigned int flags);
315
316	/* Prints out the target iff non-NULL: put space at end */
317	void (*print)(const void *ip,
318		      const struct xt_entry_target *target, int numeric);
319
320	/* Saves the targinfo in parsable form to stdout. */
321	void (*save)(const void *ip,
322		     const struct xt_entry_target *target);
323
324	/* Pointer to list of extra command-line options */
325	const struct option *extra_opts;
326
327	/* New parser */
328	void (*x6_parse)(struct xt_option_call *);
329	void (*x6_fcheck)(struct xt_fcheck_call *);
330	const struct xt_option_entry *x6_options;
331
332	size_t udata_size;
333
334	/* Ignore these men behind the curtain: */
335	void *udata;
336	unsigned int option_offset;
337	struct xt_entry_target *t;
338	unsigned int tflags;
339	unsigned int used;
340	unsigned int loaded; /* simulate loading so options are merged properly */
341};
342
343struct xtables_rule_match {
344	struct xtables_rule_match *next;
345	struct xtables_match *match;
346	/* Multiple matches of the same type: the ones before
347	   the current one are completed from parsing point of view */
348	bool completed;
349};
350
351/**
352 * struct xtables_pprot -
353 *
354 * A few hardcoded protocols for 'all' and in case the user has no
355 * /etc/protocols.
356 */
357struct xtables_pprot {
358	const char *name;
359	u_int8_t num;
360};
361
362enum xtables_tryload {
363	XTF_DONT_LOAD,
364	XTF_DURING_LOAD,
365	XTF_TRY_LOAD,
366	XTF_LOAD_MUST_SUCCEED,
367};
368
369enum xtables_exittype {
370	OTHER_PROBLEM = 1,
371	PARAMETER_PROBLEM,
372	VERSION_PROBLEM,
373	RESOURCE_PROBLEM,
374	XTF_ONLY_ONCE,
375	XTF_NO_INVERT,
376	XTF_BAD_VALUE,
377	XTF_ONE_ACTION,
378};
379
380struct xtables_globals
381{
382	unsigned int option_offset;
383	const char *program_name, *program_version;
384	struct option *orig_opts;
385	struct option *opts;
386	void (*exit_err)(enum xtables_exittype status, const char *msg, ...) __attribute__((noreturn, format(printf,2,3)));
387};
388
389#define XT_GETOPT_TABLEEND {.name = NULL, .has_arg = false}
390
391#ifdef __cplusplus
392extern "C" {
393#endif
394
395extern const char *xtables_modprobe_program;
396extern struct xtables_match *xtables_matches;
397extern struct xtables_target *xtables_targets;
398
399extern void xtables_init(void);
400extern void xtables_set_nfproto(uint8_t);
401extern void *xtables_calloc(size_t, size_t);
402extern void *xtables_malloc(size_t);
403extern void *xtables_realloc(void *, size_t);
404
405extern int xtables_insmod(const char *, const char *, bool);
406extern int xtables_load_ko(const char *, bool);
407extern int xtables_set_params(struct xtables_globals *xtp);
408extern void xtables_free_opts(int reset_offset);
409extern struct option *xtables_merge_options(struct option *origopts,
410	struct option *oldopts, const struct option *newopts,
411	unsigned int *option_offset);
412
413extern int xtables_init_all(struct xtables_globals *xtp, uint8_t nfproto);
414extern struct xtables_match *xtables_find_match(const char *name,
415	enum xtables_tryload, struct xtables_rule_match **match);
416extern struct xtables_target *xtables_find_target(const char *name,
417	enum xtables_tryload);
418
419/* Your shared library should call one of these. */
420extern void xtables_register_match(struct xtables_match *me);
421extern void xtables_register_matches(struct xtables_match *, unsigned int);
422extern void xtables_register_target(struct xtables_target *me);
423extern void xtables_register_targets(struct xtables_target *, unsigned int);
424
425extern bool xtables_strtoul(const char *, char **, uintmax_t *,
426	uintmax_t, uintmax_t);
427extern bool xtables_strtoui(const char *, char **, unsigned int *,
428	unsigned int, unsigned int);
429extern int xtables_service_to_port(const char *name, const char *proto);
430extern u_int16_t xtables_parse_port(const char *port, const char *proto);
431extern void
432xtables_parse_interface(const char *arg, char *vianame, unsigned char *mask);
433
434/* this is a special 64bit data type that is 8-byte aligned */
435#define aligned_u64 u_int64_t __attribute__((aligned(8)))
436
437extern struct xtables_globals *xt_params;
438#define xtables_error (xt_params->exit_err)
439
440extern void xtables_param_act(unsigned int, const char *, ...);
441
442extern const char *xtables_ipaddr_to_numeric(const struct in_addr *);
443extern const char *xtables_ipaddr_to_anyname(const struct in_addr *);
444extern const char *xtables_ipmask_to_numeric(const struct in_addr *);
445extern struct in_addr *xtables_numeric_to_ipaddr(const char *);
446extern struct in_addr *xtables_numeric_to_ipmask(const char *);
447extern int xtables_ipmask_to_cidr(const struct in_addr *);
448extern void xtables_ipparse_any(const char *, struct in_addr **,
449	struct in_addr *, unsigned int *);
450extern void xtables_ipparse_multiple(const char *, struct in_addr **,
451	struct in_addr **, unsigned int *);
452
453extern struct in6_addr *xtables_numeric_to_ip6addr(const char *);
454extern const char *xtables_ip6addr_to_numeric(const struct in6_addr *);
455extern const char *xtables_ip6addr_to_anyname(const struct in6_addr *);
456extern const char *xtables_ip6mask_to_numeric(const struct in6_addr *);
457extern int xtables_ip6mask_to_cidr(const struct in6_addr *);
458extern void xtables_ip6parse_any(const char *, struct in6_addr **,
459	struct in6_addr *, unsigned int *);
460extern void xtables_ip6parse_multiple(const char *, struct in6_addr **,
461	struct in6_addr **, unsigned int *);
462
463/**
464 * Print the specified value to standard output, quoting dangerous
465 * characters if required.
466 */
467extern void xtables_save_string(const char *value);
468
469#if defined(ALL_INCLUSIVE) || defined(NO_SHARED_LIBS)
470#	ifdef _INIT
471#		undef _init
472#		define _init _INIT
473#	endif
474	extern void init_extensions(void);
475	extern void init_extensions4(void);
476	extern void init_extensions6(void);
477#else
478#	define _init __attribute__((constructor)) _INIT
479#endif
480
481extern const struct xtables_pprot xtables_chain_protos[];
482extern u_int16_t xtables_parse_protocol(const char *s);
483
484/* kernel revision handling */
485extern int kernel_version;
486extern void get_kernel_version(void);
487#define LINUX_VERSION(x,y,z)	(0x10000*(x) + 0x100*(y) + z)
488#define LINUX_VERSION_MAJOR(x)	(((x)>>16) & 0xFF)
489#define LINUX_VERSION_MINOR(x)	(((x)>> 8) & 0xFF)
490#define LINUX_VERSION_PATCH(x)	( (x)      & 0xFF)
491
492/* xtoptions.c */
493extern void xtables_option_metavalidate(const char *,
494					const struct xt_option_entry *);
495extern struct option *xtables_options_xfrm(struct option *, struct option *,
496					   const struct xt_option_entry *,
497					   unsigned int *);
498extern void xtables_option_parse(struct xt_option_call *);
499extern void xtables_option_tpcall(unsigned int, char **, bool,
500				  struct xtables_target *, void *);
501extern void xtables_option_mpcall(unsigned int, char **, bool,
502				  struct xtables_match *, void *);
503extern void xtables_option_tfcall(struct xtables_target *);
504extern void xtables_option_mfcall(struct xtables_match *);
505extern void xtables_options_fcheck(const char *, unsigned int,
506				   const struct xt_option_entry *);
507
508extern struct xtables_lmap *xtables_lmap_init(const char *);
509extern void xtables_lmap_free(struct xtables_lmap *);
510extern int xtables_lmap_name2id(const struct xtables_lmap *, const char *);
511extern const char *xtables_lmap_id2name(const struct xtables_lmap *, int);
512
513#ifdef XTABLES_INTERNAL
514
515/* Shipped modules rely on this... */
516
517#	ifndef ARRAY_SIZE
518#		define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
519#	endif
520
521extern void _init(void);
522
523#endif
524
525#ifdef __cplusplus
526} /* extern "C" */
527#endif
528
529#endif /* _XTABLES_H */
530