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

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __NET_FIB_RULES_H
#define __NET_FIB_RULES_H

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/fib_rules.h>
#include <linux/refcount.h>
#include <net/flow.h>
#include <net/rtnetlink.h>
#include <net/fib_notifier.h>
#include <linux/indirect_call_wrapper.h>

struct fib_kuid_range {
	kuid_t start;
	kuid_t end;
};

struct fib_rule {
	struct list_head	list;
	int			iifindex;
	int			oifindex;
	u32			mark;
	u32			mark_mask;
	u32			flags;
	u32			table;
	u8			action;
	u8			l3mdev;
	u8                      proto;
	u8			ip_proto;
	u32			target;
	__be64			tun_id;
	struct fib_rule __rcu	*ctarget;
	struct net		*fr_net;

	refcount_t		refcnt;
	u32			pref;
	int			suppress_ifgroup;
	int			suppress_prefixlen;
	char			iifname[IFNAMSIZ];
	char			oifname[IFNAMSIZ];
	struct fib_kuid_range	uid_range;
	struct fib_rule_port_range	sport_range;
	struct fib_rule_port_range	dport_range;
	u16			sport_mask;
	u16			dport_mask;
	u8                      iif_is_l3_master;
	u8                      oif_is_l3_master;
	struct rcu_head		rcu;
};

struct fib_lookup_arg {
	void			*lookup_ptr;
	const void		*lookup_data;
	void			*result;
	struct fib_rule		*rule;
	u32			table;
	int			flags;
#define FIB_LOOKUP_NOREF		1
#define FIB_LOOKUP_IGNORE_LINKSTATE	2
};

struct fib_rules_ops {
	int			family;
	struct list_head	list;
	int			rule_size;
	int			addr_size;
	int			unresolved_rules;
	int			nr_goto_rules;
	unsigned int		fib_rules_seq;

	int			(*action)(struct fib_rule *,
					  struct flowi *, int,
					  struct fib_lookup_arg *);
	bool			(*suppress)(struct fib_rule *, int,
					    struct fib_lookup_arg *);
	int			(*match)(struct fib_rule *,
					 struct flowi *, int);
	int			(*configure)(struct fib_rule *,
					     struct sk_buff *,
					     struct fib_rule_hdr *,
					     struct nlattr **,
					     struct netlink_ext_ack *);
	int			(*delete)(struct fib_rule *);
	int			(*compare)(struct fib_rule *,
					   struct fib_rule_hdr *,
					   struct nlattr **);
	int			(*fill)(struct fib_rule *, struct sk_buff *,
					struct fib_rule_hdr *);
	size_t			(*nlmsg_payload)(struct fib_rule *);

	/* Called after modifications to the rules set, must flush
	 * the route cache if one exists. */
	void			(*flush_cache)(struct fib_rules_ops *ops);

	int			nlgroup;
	struct list_head	rules_list;
	struct module		*owner;
	struct net		*fro_net;
	struct rcu_head		rcu;
};

struct fib_rule_notifier_info {
	struct fib_notifier_info info; /* must be first */
	struct fib_rule *rule;
};

static inline void fib_rule_get(struct fib_rule *rule)
{
	refcount_inc(&rule->refcnt);
}

static inline void fib_rule_put(struct fib_rule *rule)
{
	if (refcount_dec_and_test(&rule->refcnt))
		kfree_rcu(rule, rcu);
}

#ifdef CONFIG_NET_L3_MASTER_DEV
static inline u32 fib_rule_get_table(struct fib_rule *rule,
				     struct fib_lookup_arg *arg)
{
	return rule->l3mdev ? arg->table : rule->table;
}
#else
static inline u32 fib_rule_get_table(struct fib_rule *rule,
				     struct fib_lookup_arg *arg)
{
	return rule->table;
}
#endif

static inline u32 frh_get_table(struct fib_rule_hdr *frh, struct nlattr **nla)
{
	if (nla[FRA_TABLE])
		return nla_get_u32(nla[FRA_TABLE]);
	return frh->table;
}

static inline bool fib_rule_port_range_set(const struct fib_rule_port_range *range)
{
	return range->start != 0 && range->end != 0;
}

static inline bool fib_rule_port_inrange(const struct fib_rule_port_range *a,
					 __be16 port)
{
	return ntohs(port) >= a->start &&
		ntohs(port) <= a->end;
}

static inline bool fib_rule_port_match(const struct fib_rule_port_range *range,
				       u16 port_mask, __be16 port)
{
	if ((range->start ^ ntohs(port)) & port_mask)
		return false;
	if (!port_mask && fib_rule_port_range_set(range) &&
	    !fib_rule_port_inrange(range, port))
		return false;
	return true;
}

static inline bool fib_rule_port_range_valid(const struct fib_rule_port_range *a)
{
	return a->start != 0 && a->end != 0 && a->end < 0xffff &&
		a->start <= a->end;
}

static inline bool fib_rule_port_range_compare(struct fib_rule_port_range *a,
					       struct fib_rule_port_range *b)
{
	return a->start == b->start &&
		a->end == b->end;
}

static inline bool
fib_rule_port_is_range(const struct fib_rule_port_range *range)
{
	return range->start != range->end;
}

static inline bool fib_rule_requires_fldissect(struct fib_rule *rule)
{
	return rule->iifindex != LOOPBACK_IFINDEX && (rule->ip_proto ||
		fib_rule_port_range_set(&rule->sport_range) ||
		fib_rule_port_range_set(&rule->dport_range));
}

struct fib_rules_ops *fib_rules_register(const struct fib_rules_ops *,
					 struct net *);
void fib_rules_unregister(struct fib_rules_ops *);

int fib_rules_lookup(struct fib_rules_ops *, struct flowi *, int flags,
		     struct fib_lookup_arg *);
int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table);
bool fib_rule_matchall(const struct fib_rule *rule);
int fib_rules_dump(struct net *net, struct notifier_block *nb, int family,
		   struct netlink_ext_ack *extack);
unsigned int fib_rules_seq_read(const struct net *net, int family);

int fib_newrule(struct net *net, struct sk_buff *skb, struct nlmsghdr *nlh,
		struct netlink_ext_ack *extack, bool rtnl_held);
int fib_delrule(struct net *net, struct sk_buff *skb, struct nlmsghdr *nlh,
		struct netlink_ext_ack *extack, bool rtnl_held);

INDIRECT_CALLABLE_DECLARE(int fib6_rule_match(struct fib_rule *rule,
					    struct flowi *fl, int flags));
INDIRECT_CALLABLE_DECLARE(int fib4_rule_match(struct fib_rule *rule,
					    struct flowi *fl, int flags));

INDIRECT_CALLABLE_DECLARE(int fib6_rule_action(struct fib_rule *rule,
			    struct flowi *flp, int flags,
			    struct fib_lookup_arg *arg));
INDIRECT_CALLABLE_DECLARE(int fib4_rule_action(struct fib_rule *rule,
			    struct flowi *flp, int flags,
			    struct fib_lookup_arg *arg));

INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
						int flags,
						struct fib_lookup_arg *arg));
INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
						int flags,
						struct fib_lookup_arg *arg));
#endif
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __NET_FIB_RULES_H
	3	#define __NET_FIB_RULES_H
	4
	5	#include <linux/types.h>
	6	#include <linux/slab.h>
	7	#include <linux/netdevice.h>
	8	#include <linux/fib_rules.h>
	9	#include <linux/refcount.h>
	10	#include <net/flow.h>
	11	#include <net/rtnetlink.h>
	12	#include <net/fib_notifier.h>
	13	#include <linux/indirect_call_wrapper.h>
	14
	15	struct fib_kuid_range {
	16	kuid_t start;
	17	kuid_t end;
	18	};
	19
	20	struct fib_rule {
	21	struct list_head list;
	22	int iifindex;
	23	int oifindex;
	24	u32 mark;
	25	u32 mark_mask;
	26	u32 flags;
	27	u32 table;
	28	u8 action;
	29	u8 l3mdev;
	30	u8 proto;
	31	u8 ip_proto;
	32	u32 target;
	33	__be64 tun_id;
	34	struct fib_rule __rcu *ctarget;
	35	struct net *fr_net;
	36
	37	refcount_t refcnt;
	38	u32 pref;
	39	int suppress_ifgroup;
	40	int suppress_prefixlen;
	41	char iifname[IFNAMSIZ];
	42	char oifname[IFNAMSIZ];
	43	struct fib_kuid_range uid_range;
	44	struct fib_rule_port_range sport_range;
	45	struct fib_rule_port_range dport_range;
	46	u16 sport_mask;
	47	u16 dport_mask;
	48	u8 iif_is_l3_master;
	49	u8 oif_is_l3_master;
	50	struct rcu_head rcu;
	51	};
	52
	53	struct fib_lookup_arg {
	54	void *lookup_ptr;
	55	const void *lookup_data;
	56	void *result;
	57	struct fib_rule *rule;
	58	u32 table;
	59	int flags;
	60	#define FIB_LOOKUP_NOREF 1
	61	#define FIB_LOOKUP_IGNORE_LINKSTATE 2
	62	};
	63
	64	struct fib_rules_ops {
	65	int family;
	66	struct list_head list;
	67	int rule_size;
	68	int addr_size;
	69	int unresolved_rules;
	70	int nr_goto_rules;
	71	unsigned int fib_rules_seq;
	72
	73	int (action)(struct fib_rule ,
	74	struct flowi *, int,
	75	struct fib_lookup_arg *);
	76	bool (suppress)(struct fib_rule , int,
	77	struct fib_lookup_arg *);
	78	int (match)(struct fib_rule ,
	79	struct flowi *, int);
	80	int (configure)(struct fib_rule ,
	81	struct sk_buff *,
	82	struct fib_rule_hdr *,
	83	struct nlattr **,
	84	struct netlink_ext_ack *);
	85	int (delete)(struct fib_rule );
	86	int (compare)(struct fib_rule ,
	87	struct fib_rule_hdr *,
	88	struct nlattr **);
	89	int (fill)(struct fib_rule , struct sk_buff *,
	90	struct fib_rule_hdr *);
	91	size_t (nlmsg_payload)(struct fib_rule );
	92
	93	/* Called after modifications to the rules set, must flush
	94	* the route cache if one exists. */
	95	void (flush_cache)(struct fib_rules_ops ops);
	96
	97	int nlgroup;
	98	struct list_head rules_list;
	99	struct module *owner;
	100	struct net *fro_net;
	101	struct rcu_head rcu;
	102	};
	103
	104	struct fib_rule_notifier_info {
	105	struct fib_notifier_info info; /* must be first */
	106	struct fib_rule *rule;
	107	};
	108
	109	static inline void fib_rule_get(struct fib_rule *rule)
	110	{
	111	refcount_inc(&rule->refcnt);
	112	}
	113
	114	static inline void fib_rule_put(struct fib_rule *rule)
	115	{
	116	if (refcount_dec_and_test(&rule->refcnt))
	117	kfree_rcu(rule, rcu);
	118	}
	119
	120	#ifdef CONFIG_NET_L3_MASTER_DEV
	121	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	122	struct fib_lookup_arg *arg)
	123	{
	124	return rule->l3mdev ? arg->table : rule->table;
	125	}
	126	#else
	127	static inline u32 fib_rule_get_table(struct fib_rule *rule,
	128	struct fib_lookup_arg *arg)
	129	{
	130	return rule->table;
	131	}
	132	#endif
	133
	134	static inline u32 frh_get_table(struct fib_rule_hdr frh, struct nlattr *nla)
	135	{
	136	if (nla[FRA_TABLE])
	137	return nla_get_u32(nla[FRA_TABLE]);
	138	return frh->table;
	139	}
	140
	141	static inline bool fib_rule_port_range_set(const struct fib_rule_port_range *range)
	142	{
	143	return range->start != 0 && range->end != 0;
	144	}
	145
	146	static inline bool fib_rule_port_inrange(const struct fib_rule_port_range *a,
	147	__be16 port)
	148	{
	149	return ntohs(port) >= a->start &&
	150	ntohs(port) <= a->end;
	151	}
	152
	153	static inline bool fib_rule_port_match(const struct fib_rule_port_range *range,
	154	u16 port_mask, __be16 port)
	155	{
	156	if ((range->start ^ ntohs(port)) & port_mask)
	157	return false;
	158	if (!port_mask && fib_rule_port_range_set(range) &&
	159	!fib_rule_port_inrange(range, port))
	160	return false;
	161	return true;
	162	}
	163
	164	static inline bool fib_rule_port_range_valid(const struct fib_rule_port_range *a)
	165	{
	166	return a->start != 0 && a->end != 0 && a->end < 0xffff &&
	167	a->start <= a->end;
	168	}
	169
	170	static inline bool fib_rule_port_range_compare(struct fib_rule_port_range *a,
	171	struct fib_rule_port_range *b)
	172	{
	173	return a->start == b->start &&
	174	a->end == b->end;
	175	}
	176
	177	static inline bool
	178	fib_rule_port_is_range(const struct fib_rule_port_range *range)
	179	{
	180	return range->start != range->end;
	181	}
	182
	183	static inline bool fib_rule_requires_fldissect(struct fib_rule *rule)
	184	{
	185	return rule->iifindex != LOOPBACK_IFINDEX && (rule->ip_proto \|\|
	186	fib_rule_port_range_set(&rule->sport_range) \|\|
	187	fib_rule_port_range_set(&rule->dport_range));
	188	}
	189
	190	struct fib_rules_ops fib_rules_register(const struct fib_rules_ops ,
	191	struct net *);
	192	void fib_rules_unregister(struct fib_rules_ops *);
	193
	194	int fib_rules_lookup(struct fib_rules_ops , struct flowi , int flags,
	195	struct fib_lookup_arg *);
	196	int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table);
	197	bool fib_rule_matchall(const struct fib_rule *rule);
	198	int fib_rules_dump(struct net net, struct notifier_block nb, int family,
	199	struct netlink_ext_ack *extack);
	200	unsigned int fib_rules_seq_read(const struct net *net, int family);
	201
	202	int fib_newrule(struct net net, struct sk_buff skb, struct nlmsghdr *nlh,
	203	struct netlink_ext_ack *extack, bool rtnl_held);
	204	int fib_delrule(struct net net, struct sk_buff skb, struct nlmsghdr *nlh,
	205	struct netlink_ext_ack *extack, bool rtnl_held);
	206
	207	INDIRECT_CALLABLE_DECLARE(int fib6_rule_match(struct fib_rule *rule,
	208	struct flowi *fl, int flags));
	209	INDIRECT_CALLABLE_DECLARE(int fib4_rule_match(struct fib_rule *rule,
	210	struct flowi *fl, int flags));
	211
	212	INDIRECT_CALLABLE_DECLARE(int fib6_rule_action(struct fib_rule *rule,
	213	struct flowi *flp, int flags,
	214	struct fib_lookup_arg *arg));
	215	INDIRECT_CALLABLE_DECLARE(int fib4_rule_action(struct fib_rule *rule,
	216	struct flowi *flp, int flags,
	217	struct fib_lookup_arg *arg));
	218
	219	INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
	220	int flags,
	221	struct fib_lookup_arg *arg));
	222	INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
	223	int flags,
	224	struct fib_lookup_arg *arg));
	225	#endif