[linux-2.6-block.git] / include / net / lwtunnel.h

#ifndef __NET_LWTUNNEL_H
#define __NET_LWTUNNEL_H 1

#include <linux/lwtunnel.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <net/route.h>

#define LWTUNNEL_HASH_BITS   7
#define LWTUNNEL_HASH_SIZE   (1 << LWTUNNEL_HASH_BITS)

/* lw tunnel state flags */
#define LWTUNNEL_STATE_OUTPUT_REDIRECT	BIT(0)
#define LWTUNNEL_STATE_INPUT_REDIRECT	BIT(1)

struct lwtunnel_state {
	__u16		type;
	__u16		flags;
	atomic_t	refcnt;
	int		(*orig_output)(struct net *net, struct sock *sk, struct sk_buff *skb);
	int		(*orig_input)(struct sk_buff *);
	int             len;
	__u8            data[0];
};

struct lwtunnel_encap_ops {
	int (*build_state)(struct net_device *dev, struct nlattr *encap,
			   unsigned int family, const void *cfg,
			   struct lwtunnel_state **ts);
	int (*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
	int (*input)(struct sk_buff *skb);
	int (*fill_encap)(struct sk_buff *skb,
			  struct lwtunnel_state *lwtstate);
	int (*get_encap_size)(struct lwtunnel_state *lwtstate);
	int (*cmp_encap)(struct lwtunnel_state *a, struct lwtunnel_state *b);
};

#ifdef CONFIG_LWTUNNEL
static inline void lwtstate_free(struct lwtunnel_state *lws)
{
	kfree(lws);
}

static inline struct lwtunnel_state *
lwtstate_get(struct lwtunnel_state *lws)
{
	if (lws)
		atomic_inc(&lws->refcnt);

	return lws;
}

static inline void lwtstate_put(struct lwtunnel_state *lws)
{
	if (!lws)
		return;

	if (atomic_dec_and_test(&lws->refcnt))
		lwtstate_free(lws);
}

static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
{
	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_OUTPUT_REDIRECT))
		return true;

	return false;
}

static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
{
	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_INPUT_REDIRECT))
		return true;

	return false;
}
int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
			   unsigned int num);
int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
			   unsigned int num);
int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
			 struct nlattr *encap,
			 unsigned int family, const void *cfg,
			 struct lwtunnel_state **lws);
int lwtunnel_fill_encap(struct sk_buff *skb,
			struct lwtunnel_state *lwtstate);
int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate);
struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len);
int lwtunnel_cmp_encap(struct lwtunnel_state *a, struct lwtunnel_state *b);
int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb);
int lwtunnel_input(struct sk_buff *skb);

#else

static inline void lwtstate_free(struct lwtunnel_state *lws)
{
}

static inline struct lwtunnel_state *
lwtstate_get(struct lwtunnel_state *lws)
{
	return lws;
}

static inline void lwtstate_put(struct lwtunnel_state *lws)
{
}

static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
{
	return false;
}

static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
{
	return false;
}

static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
					 unsigned int num)
{
	return -EOPNOTSUPP;

}

static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
					 unsigned int num)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
				       struct nlattr *encap,
				       unsigned int family, const void *cfg,
				       struct lwtunnel_state **lws)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_fill_encap(struct sk_buff *skb,
				      struct lwtunnel_state *lwtstate)
{
	return 0;
}

static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
{
	return 0;
}

static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
{
	return NULL;
}

static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
				     struct lwtunnel_state *b)
{
	return 0;
}

static inline int lwtunnel_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

static inline int lwtunnel_input(struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

#endif /* CONFIG_LWTUNNEL */

#define MODULE_ALIAS_RTNL_LWT(encap_type) MODULE_ALIAS("rtnl-lwt-" __stringify(encap_type))

#endif /* __NET_LWTUNNEL_H */
Commit	Line	Data
499a2425 RP	1	#ifndef __NET_LWTUNNEL_H
	2	#define __NET_LWTUNNEL_H 1
	3
	4	#include <linux/lwtunnel.h>
	5	#include <linux/netdevice.h>
	6	#include <linux/skbuff.h>
	7	#include <linux/types.h>
	8	#include <net/route.h>
	9
	10	#define LWTUNNEL_HASH_BITS 7
	11	#define LWTUNNEL_HASH_SIZE (1 << LWTUNNEL_HASH_BITS)
	12
	13	/* lw tunnel state flags */
25368623 TH	14	#define LWTUNNEL_STATE_OUTPUT_REDIRECT BIT(0)
25368623 TH	15	#define LWTUNNEL_STATE_INPUT_REDIRECT BIT(1)
499a2425 RP	16
	17	struct lwtunnel_state {
	18	__u16 type;
	19	__u16 flags;
	20	atomic_t refcnt;
ede2059d	21	int (orig_output)(struct net net, struct sock sk, struct sk_buff skb);
25368623	22	int (orig_input)(struct sk_buff );
499a2425 RP	23	int len;
	24	__u8 data[0];
	25	};
	26
	27	struct lwtunnel_encap_ops {
	28	int (build_state)(struct net_device dev, struct nlattr *encap,
127eb7cd	29	unsigned int family, const void *cfg,
499a2425	30	struct lwtunnel_state **ts);
ede2059d	31	int (output)(struct net net, struct sock sk, struct sk_buff skb);
25368623	32	int (input)(struct sk_buff skb);
499a2425 RP	33	int (fill_encap)(struct sk_buff skb,
	34	struct lwtunnel_state *lwtstate);
	35	int (get_encap_size)(struct lwtunnel_state lwtstate);
	36	int (cmp_encap)(struct lwtunnel_state a, struct lwtunnel_state *b);
	37	};
	38
499a2425	39	#ifdef CONFIG_LWTUNNEL
df383e62 JB	40	static inline void lwtstate_free(struct lwtunnel_state *lws)
	41	{
	42	kfree(lws);
	43	}
	44
5a6228a0 ND	45	static inline struct lwtunnel_state *
5a6228a0 ND	46	lwtstate_get(struct lwtunnel_state *lws)
499a2425	47	{
5a6228a0 ND	48	if (lws)
	49	atomic_inc(&lws->refcnt);
	50
	51	return lws;
499a2425 RP	52	}
499a2425 RP	53
5a6228a0	54	static inline void lwtstate_put(struct lwtunnel_state *lws)
499a2425 RP	55	{
	56	if (!lws)
	57	return;
	58
	59	if (atomic_dec_and_test(&lws->refcnt))
df383e62	60	lwtstate_free(lws);
499a2425 RP	61	}
	62
	63	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	64	{
	65	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_OUTPUT_REDIRECT))
	66	return true;
	67
	68	return false;
	69	}
	70
25368623 TH	71	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	72	{
	73	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_INPUT_REDIRECT))
	74	return true;
	75
	76	return false;
	77	}
499a2425 RP	78	int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	79	unsigned int num);
	80	int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	81	unsigned int num);
	82	int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
	83	struct nlattr *encap,
127eb7cd	84	unsigned int family, const void *cfg,
499a2425 RP	85	struct lwtunnel_state **lws);
	86	int lwtunnel_fill_encap(struct sk_buff *skb,
	87	struct lwtunnel_state *lwtstate);
	88	int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate);
	89	struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len);
	90	int lwtunnel_cmp_encap(struct lwtunnel_state a, struct lwtunnel_state b);
ede2059d	91	int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb);
25368623	92	int lwtunnel_input(struct sk_buff *skb);
499a2425 RP	93
	94	#else
	95
824e7383 YX	96	static inline void lwtstate_free(struct lwtunnel_state *lws)
	97	{
	98	}
	99
5a6228a0 ND	100	static inline struct lwtunnel_state *
5a6228a0 ND	101	lwtstate_get(struct lwtunnel_state *lws)
499a2425	102	{
5a6228a0	103	return lws;
499a2425 RP	104	}
499a2425 RP	105
5a6228a0	106	static inline void lwtstate_put(struct lwtunnel_state *lws)
499a2425 RP	107	{
	108	}
	109
	110	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	111	{
	112	return false;
	113	}
	114
25368623 TH	115	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	116	{
	117	return false;
	118	}
	119
499a2425 RP	120	static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	121	unsigned int num)
	122	{
	123	return -EOPNOTSUPP;
	124
	125	}
	126
	127	static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	128	unsigned int num)
	129	{
	130	return -EOPNOTSUPP;
	131	}
	132
	133	static inline int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
	134	struct nlattr *encap,
127eb7cd	135	unsigned int family, const void *cfg,
499a2425 RP	136	struct lwtunnel_state **lws)
	137	{
	138	return -EOPNOTSUPP;
	139	}
	140
	141	static inline int lwtunnel_fill_encap(struct sk_buff *skb,
	142	struct lwtunnel_state *lwtstate)
	143	{
	144	return 0;
	145	}
	146
	147	static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	148	{
	149	return 0;
	150	}
	151
	152	static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
	153	{
	154	return NULL;
	155	}
	156
	157	static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
	158	struct lwtunnel_state *b)
	159	{
	160	return 0;
	161	}
	162
ede2059d	163	static inline int lwtunnel_output(struct net net, struct sock sk, struct sk_buff *skb)
ffce4196 RP	164	{
	165	return -EOPNOTSUPP;
	166	}
	167
25368623 TH	168	static inline int lwtunnel_input(struct sk_buff *skb)
	169	{
	170	return -EOPNOTSUPP;
	171	}
	172
745041e2 RS	173	#endif /* CONFIG_LWTUNNEL */
	174
	175	#define MODULE_ALIAS_RTNL_LWT(encap_type) MODULE_ALIAS("rtnl-lwt-" __stringify(encap_type))
499a2425 RP	176
499a2425 RP	177	#endif /* __NET_LWTUNNEL_H */