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