[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_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,
				       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_input(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	89	int lwtunnel_output(struct sock sk, struct sk_buff skb);
25368623	90	int lwtunnel_input(struct sk_buff *skb);
499a2425 RP	91
	92	#else
	93
824e7383 YX	94	static inline void lwtstate_free(struct lwtunnel_state *lws)
	95	{
	96	}
	97
5a6228a0 ND	98	static inline struct lwtunnel_state *
5a6228a0 ND	99	lwtstate_get(struct lwtunnel_state *lws)
499a2425	100	{
5a6228a0	101	return lws;
499a2425 RP	102	}
499a2425 RP	103
5a6228a0	104	static inline void lwtstate_put(struct lwtunnel_state *lws)
499a2425 RP	105	{
	106	}
	107
	108	static inline bool lwtunnel_output_redirect(struct lwtunnel_state *lwtstate)
	109	{
	110	return false;
	111	}
	112
25368623 TH	113	static inline bool lwtunnel_input_redirect(struct lwtunnel_state *lwtstate)
	114	{
	115	return false;
	116	}
	117
499a2425 RP	118	static inline int lwtunnel_encap_add_ops(const struct lwtunnel_encap_ops *op,
	119	unsigned int num)
	120	{
	121	return -EOPNOTSUPP;
	122
	123	}
	124
	125	static inline int lwtunnel_encap_del_ops(const struct lwtunnel_encap_ops *op,
	126	unsigned int num)
	127	{
	128	return -EOPNOTSUPP;
	129	}
	130
	131	static inline int lwtunnel_build_state(struct net_device *dev, u16 encap_type,
	132	struct nlattr *encap,
	133	struct lwtunnel_state **lws)
	134	{
	135	return -EOPNOTSUPP;
	136	}
	137
	138	static inline int lwtunnel_fill_encap(struct sk_buff *skb,
	139	struct lwtunnel_state *lwtstate)
	140	{
	141	return 0;
	142	}
	143
	144	static inline int lwtunnel_get_encap_size(struct lwtunnel_state *lwtstate)
	145	{
	146	return 0;
	147	}
	148
	149	static inline struct lwtunnel_state *lwtunnel_state_alloc(int hdr_len)
	150	{
	151	return NULL;
	152	}
	153
	154	static inline int lwtunnel_cmp_encap(struct lwtunnel_state *a,
	155	struct lwtunnel_state *b)
	156	{
	157	return 0;
	158	}
	159
ffce4196 RP	160	static inline int lwtunnel_output(struct sock sk, struct sk_buff skb)
	161	{
	162	return -EOPNOTSUPP;
	163	}
	164
25368623 TH	165	static inline int lwtunnel_input(struct sk_buff *skb)
	166	{
	167	return -EOPNOTSUPP;
	168	}
	169
499a2425 RP	170	#endif
	171
	172	#endif /* __NET_LWTUNNEL_H */