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