[deliverable/linux.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 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,
			   struct lwtunnel_state **ts);
	int (*output)(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,
			 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 sock *sk, struct sk_buff *skb);
int lwtunnel_output6(struct sock *sk, struct sk_buff *skb);
int lwtunnel_input(struct sk_buff *skb);
int lwtunnel_input6(struct sk_buff *skb);

#else

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,
				       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 sock *sk, struct sk_buff *skb)
{
	return -EOPNOTSUPP;
}

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

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

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

#endif

#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;
25368623 TH	21	int (orig_output)(struct sock sk, struct sk_buff *skb);
25368623 TH	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,
	29	struct lwtunnel_state **ts);
	30	int (output)(struct sock sk, struct sk_buff *skb);
25368623	31	int (input)(struct sk_buff skb);
499a2425 RP	32	int (fill_encap)(struct sk_buff skb,
	33	struct lwtunnel_state *lwtstate);
	34	int (get_encap_size)(struct lwtunnel_state lwtstate);
	35	int (cmp_encap)(struct lwtunnel_state a, struct lwtunnel_state *b);
	36	};
	37
499a2425	38	#ifdef CONFIG_LWTUNNEL
df383e62 JB	39	static inline void lwtstate_free(struct lwtunnel_state *lws)
	40	{
	41	kfree(lws);
	42	}
	43
5a6228a0 ND	44	static inline struct lwtunnel_state *
5a6228a0 ND	45	lwtstate_get(struct lwtunnel_state *lws)
499a2425	46	{
5a6228a0 ND	47	if (lws)
	48	atomic_inc(&lws->refcnt);
	49
	50	return lws;
499a2425 RP	51	}
499a2425 RP	52
5a6228a0	53	static inline void lwtstate_put(struct lwtunnel_state *lws)
499a2425 RP	54	{
	55	if (!lws)
	56	return;
	57
	58	if (atomic_dec_and_test(&lws->refcnt))
df383e62	59	lwtstate_free(lws);
499a2425 RP	60	}
	61
	62	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	63	{
	64	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_OUTPUT_REDIRECT))
	65	return true;
	66
	67	return false;
	68	}
	69
25368623 TH	70	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	71	{
	72	if (lwtstate && (lwtstate->flags & LWTUNNEL_STATE_INPUT_REDIRECT))
	73	return true;
	74
	75	return false;
	76	}
499a2425 RP	77	int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	78	unsigned int num);
	79	int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	80	unsigned int num);
	81	int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
	82	struct nlattr *encap,
	83	struct lwtunnel_state **lws);
	84	int lwtunnel_fill_encap(struct sk_buff *skb,
	85	struct lwtunnel_state *lwtstate);
	86	int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate);
	87	struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len);
	88	int lwtunnel_cmp_encap(struct lwtunnel_state a, struct lwtunnel_state b);
ffce4196 RP	89	int lwtunnel_output(struct sock sk, struct sk_buff skb);
ffce4196 RP	90	int lwtunnel_output6(struct sock sk, struct sk_buff skb);
25368623 TH	91	int lwtunnel_input(struct sk_buff *skb);
25368623 TH	92	int lwtunnel_input6(struct sk_buff *skb);
499a2425 RP	93
	94	#else
	95
5a6228a0 ND	96	static inline struct lwtunnel_state *
5a6228a0 ND	97	lwtstate_get(struct lwtunnel_state *lws)
499a2425	98	{
5a6228a0	99	return lws;
499a2425 RP	100	}
499a2425 RP	101
5a6228a0	102	static inline void lwtstate_put(struct lwtunnel_state *lws)
499a2425 RP	103	{
	104	}
	105
	106	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	107	{
	108	return false;
	109	}
	110
25368623 TH	111	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	112	{
	113	return false;
	114	}
	115
499a2425 RP	116	static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	117	unsigned int num)
	118	{
	119	return -EOPNOTSUPP;
	120
	121	}
	122
	123	static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	124	unsigned int num)
	125	{
	126	return -EOPNOTSUPP;
	127	}
	128
	129	static inline int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
	130	struct nlattr *encap,
	131	struct lwtunnel_state **lws)
	132	{
	133	return -EOPNOTSUPP;
	134	}
	135
	136	static inline int lwtunnel_fill_encap(struct sk_buff *skb,
	137	struct lwtunnel_state *lwtstate)
	138	{
	139	return 0;
	140	}
	141
	142	static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	143	{
	144	return 0;
	145	}
	146
	147	static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
	148	{
	149	return NULL;
	150	}
	151
	152	static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
	153	struct lwtunnel_state *b)
	154	{
	155	return 0;
	156	}
	157
ffce4196 RP	158	static inline int lwtunnel_output(struct sock sk, struct sk_buff skb)
	159	{
	160	return -EOPNOTSUPP;
	161	}
	162
	163	static inline int lwtunnel_output6(struct sock sk, struct sk_buff skb)
	164	{
	165	return -EOPNOTSUPP;
	166	}
	167
25368623 TH	168	static inline int lwtunnel_input(struct sk_buff *skb)
	169	{
	170	return -EOPNOTSUPP;
	171	}
	172
	173	static inline int lwtunnel_input6(struct sk_buff *skb)
	174	{
	175	return -EOPNOTSUPP;
	176	}
	177
499a2425 RP	178	#endif
	179
	180	#endif /* __NET_LWTUNNEL_H */