[mirror_ubuntu-artful-kernel.git] / include / linux / netfilter_bridge / ebtables.h

/*
 *  ebtables
 *
 *	Authors:
 *	Bart De Schuymer		<bdschuym@pandora.be>
 *
 *  ebtables.c,v 2.0, April, 2002
 *
 *  This code is strongly inspired by the iptables code which is
 *  Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
 */
#ifndef __LINUX_BRIDGE_EFF_H
#define __LINUX_BRIDGE_EFF_H

#include <linux/if.h>
#include <linux/if_ether.h>
#include <uapi/linux/netfilter_bridge/ebtables.h>

/* return values for match() functions */
#define EBT_MATCH 0
#define EBT_NOMATCH 1

struct ebt_match {
	struct list_head list;
	const char name[EBT_FUNCTION_MAXNAMELEN];
	bool (*match)(const struct sk_buff *skb, const struct net_device *in,
		const struct net_device *out, const struct xt_match *match,
		const void *matchinfo, int offset, unsigned int protoff,
		bool *hotdrop);
	bool (*checkentry)(const char *table, const void *entry,
		const struct xt_match *match, void *matchinfo,
		unsigned int hook_mask);
	void (*destroy)(const struct xt_match *match, void *matchinfo);
	unsigned int matchsize;
	u_int8_t revision;
	u_int8_t family;
	struct module *me;
};

struct ebt_watcher {
	struct list_head list;
	const char name[EBT_FUNCTION_MAXNAMELEN];
	unsigned int (*target)(struct sk_buff *skb,
		const struct net_device *in, const struct net_device *out,
		unsigned int hook_num, const struct xt_target *target,
		const void *targinfo);
	bool (*checkentry)(const char *table, const void *entry,
		const struct xt_target *target, void *targinfo,
		unsigned int hook_mask);
	void (*destroy)(const struct xt_target *target, void *targinfo);
	unsigned int targetsize;
	u_int8_t revision;
	u_int8_t family;
	struct module *me;
};

struct ebt_target {
	struct list_head list;
	const char name[EBT_FUNCTION_MAXNAMELEN];
	/* returns one of the standard EBT_* verdicts */
	unsigned int (*target)(struct sk_buff *skb,
		const struct net_device *in, const struct net_device *out,
		unsigned int hook_num, const struct xt_target *target,
		const void *targinfo);
	bool (*checkentry)(const char *table, const void *entry,
		const struct xt_target *target, void *targinfo,
		unsigned int hook_mask);
	void (*destroy)(const struct xt_target *target, void *targinfo);
	unsigned int targetsize;
	u_int8_t revision;
	u_int8_t family;
	struct module *me;
};

/* used for jumping from and into user defined chains (udc) */
struct ebt_chainstack {
	struct ebt_entries *chaininfo; /* pointer to chain data */
	struct ebt_entry *e; /* pointer to entry data */
	unsigned int n; /* n'th entry */
};

struct ebt_table_info {
	/* total size of the entries */
	unsigned int entries_size;
	unsigned int nentries;
	/* pointers to the start of the chains */
	struct ebt_entries *hook_entry[NF_BR_NUMHOOKS];
	/* room to maintain the stack used for jumping from and into udc */
	struct ebt_chainstack **chainstack;
	char *entries;
	struct ebt_counter counters[0] ____cacheline_aligned;
};

struct ebt_table {
	struct list_head list;
	char name[EBT_TABLE_MAXNAMELEN];
	struct ebt_replace_kernel *table;
	unsigned int valid_hooks;
	rwlock_t lock;
	/* e.g. could be the table explicitly only allows certain
	 * matches, targets, ... 0 == let it in */
	int (*check)(const struct ebt_table_info *info,
	   unsigned int valid_hooks);
	/* the data used by the kernel */
	struct ebt_table_info *private;
	struct module *me;
};

#define EBT_ALIGN(s) (((s) + (__alignof__(struct _xt_align)-1)) & \
		     ~(__alignof__(struct _xt_align)-1))
extern struct ebt_table *ebt_register_table(struct net *net,
					    const struct ebt_table *table,
					    const struct nf_hook_ops *);
extern void ebt_unregister_table(struct net *net, struct ebt_table *table,
				 const struct nf_hook_ops *);
extern unsigned int ebt_do_table(struct sk_buff *skb,
				 const struct nf_hook_state *state,
				 struct ebt_table *table);

/* True if the hook mask denotes that the rule is in a base chain,
 * used in the check() functions */
#define BASE_CHAIN (par->hook_mask & (1 << NF_BR_NUMHOOKS))
/* Clear the bit in the hook mask that tells if the rule is on a base chain */
#define CLEAR_BASE_CHAIN_BIT (par->hook_mask &= ~(1 << NF_BR_NUMHOOKS))
/* True if the target is not a standard target */
#define INVALID_TARGET (info->target < -NUM_STANDARD_TARGETS || info->target >= 0)

static inline bool ebt_invalid_target(int target)
{
	return (target < -NUM_STANDARD_TARGETS || target >= 0);
}

#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ebtables
	3	*
	4	* Authors:
	5	* Bart De Schuymer <bdschuym@pandora.be>
	6	*
	7	* ebtables.c,v 2.0, April, 2002
	8	*
069d4a7b	9	* This code is strongly inspired by the iptables code which is
1da177e4 LT	10	* Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
1da177e4 LT	11	*/
1da177e4 LT	12	#ifndef __LINUX_BRIDGE_EFF_H
1da177e4 LT	13	#define __LINUX_BRIDGE_EFF_H
1da177e4	14
24477e57 PNA	15	#include <linux/if.h>
24477e57 PNA	16	#include <linux/if_ether.h>
55c5cd3c	17	#include <uapi/linux/netfilter_bridge/ebtables.h>
1e419cd9	18
1da177e4 LT	19	/* return values for match() functions */
	20	#define EBT_MATCH 0
	21	#define EBT_NOMATCH 1
	22
d94d9fee	23	struct ebt_match {
1da177e4 LT	24	struct list_head list;
1da177e4 LT	25	const char name[EBT_FUNCTION_MAXNAMELEN];
8cc784ee	26	bool (match)(const struct sk_buff skb, const struct net_device *in,
2d06d4a5 JE	27	const struct net_device out, const struct xt_match match,
	28	const void *matchinfo, int offset, unsigned int protoff,
	29	bool *hotdrop);
	30	bool (checkentry)(const char table, const void *entry,
	31	const struct xt_match match, void matchinfo,
	32	unsigned int hook_mask);
	33	void (destroy)(const struct xt_match match, void *matchinfo);
18219d3f	34	unsigned int matchsize;
001a18d3 JE	35	u_int8_t revision;
001a18d3 JE	36	u_int8_t family;
1da177e4 LT	37	struct module *me;
	38	};
	39
d94d9fee	40	struct ebt_watcher {
1da177e4 LT	41	struct list_head list;
1da177e4 LT	42	const char name[EBT_FUNCTION_MAXNAMELEN];
2d06d4a5 JE	43	unsigned int (target)(struct sk_buff skb,
	44	const struct net_device in, const struct net_device out,
	45	unsigned int hook_num, const struct xt_target *target,
	46	const void *targinfo);
	47	bool (checkentry)(const char table, const void *entry,
	48	const struct xt_target target, void targinfo,
	49	unsigned int hook_mask);
	50	void (destroy)(const struct xt_target target, void *targinfo);
18219d3f	51	unsigned int targetsize;
001a18d3 JE	52	u_int8_t revision;
001a18d3 JE	53	u_int8_t family;
1da177e4 LT	54	struct module *me;
	55	};
	56
d94d9fee	57	struct ebt_target {
1da177e4 LT	58	struct list_head list;
1da177e4 LT	59	const char name[EBT_FUNCTION_MAXNAMELEN];
0ac6ab1f	60	/* returns one of the standard EBT_* verdicts */
2d06d4a5 JE	61	unsigned int (target)(struct sk_buff skb,
	62	const struct net_device in, const struct net_device out,
	63	unsigned int hook_num, const struct xt_target *target,
	64	const void *targinfo);
	65	bool (checkentry)(const char table, const void *entry,
	66	const struct xt_target target, void targinfo,
	67	unsigned int hook_mask);
	68	void (destroy)(const struct xt_target target, void *targinfo);
18219d3f	69	unsigned int targetsize;
001a18d3 JE	70	u_int8_t revision;
001a18d3 JE	71	u_int8_t family;
1da177e4 LT	72	struct module *me;
	73	};
	74
	75	/* used for jumping from and into user defined chains (udc) */
d94d9fee	76	struct ebt_chainstack {
1da177e4 LT	77	struct ebt_entries chaininfo; / pointer to chain data */
	78	struct ebt_entry e; / pointer to entry data */
	79	unsigned int n; /* n'th entry */
	80	};
	81
d94d9fee	82	struct ebt_table_info {
1da177e4 LT	83	/* total size of the entries */
	84	unsigned int entries_size;
	85	unsigned int nentries;
	86	/* pointers to the start of the chains */
	87	struct ebt_entries *hook_entry[NF_BR_NUMHOOKS];
	88	/* room to maintain the stack used for jumping from and into udc */
	89	struct ebt_chainstack **chainstack;
	90	char *entries;
	91	struct ebt_counter counters[0] ____cacheline_aligned;
	92	};
	93
d94d9fee	94	struct ebt_table {
1da177e4 LT	95	struct list_head list;
1da177e4 LT	96	char name[EBT_TABLE_MAXNAMELEN];
1e419cd9	97	struct ebt_replace_kernel *table;
1da177e4 LT	98	unsigned int valid_hooks;
	99	rwlock_t lock;
	100	/* e.g. could be the table explicitly only allows certain
	101	* matches, targets, ... 0 == let it in */
	102	int (check)(const struct ebt_table_info info,
	103	unsigned int valid_hooks);
	104	/* the data used by the kernel */
	105	struct ebt_table_info *private;
	106	struct module *me;
	107	};
	108
88ba136d JW	109	#define EBT_ALIGN(s) (((s) + (__alignof__(struct _xt_align)-1)) & \
88ba136d JW	110	~(__alignof__(struct _xt_align)-1))
6beceee5	111	extern struct ebt_table ebt_register_table(struct net net,
aee12a0a FW	112	const struct ebt_table *table,
	113	const struct nf_hook_ops *);
	114	extern void ebt_unregister_table(struct net net, struct ebt_table table,
	115	const struct nf_hook_ops *);
97b59c3a EB	116	extern unsigned int ebt_do_table(struct sk_buff *skb,
	117	const struct nf_hook_state *state,
	118	struct ebt_table *table);
1da177e4	119
1da177e4 LT	120	/* True if the hook mask denotes that the rule is in a base chain,
1da177e4 LT	121	* used in the check() functions */
af5d6dc2	122	#define BASE_CHAIN (par->hook_mask & (1 << NF_BR_NUMHOOKS))
1da177e4	123	/* Clear the bit in the hook mask that tells if the rule is on a base chain */
af5d6dc2	124	#define CLEAR_BASE_CHAIN_BIT (par->hook_mask &= ~(1 << NF_BR_NUMHOOKS))
1da177e4 LT	125	/* True if the target is not a standard target */
	126	#define INVALID_TARGET (info->target < -NUM_STANDARD_TARGETS \|\| info->target >= 0)
	127
c953d635 GF	128	static inline bool ebt_invalid_target(int target)
	129	{
	130	return (target < -NUM_STANDARD_TARGETS \|\| target >= 0);
	131	}
	132
1da177e4	133	#endif