fib_rules.h

  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
 15struct fib_kuid_range {
 16	kuid_t start;
 17	kuid_t end;
 18};
 19
 20struct 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
 53struct 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
 64struct 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
104struct fib_rule_notifier_info {
105	struct fib_notifier_info info; /* must be first */
106	struct fib_rule *rule;
107};
108
109static inline void fib_rule_get(struct fib_rule *rule)
110{
111	refcount_inc(&rule->refcnt);
112}
113
114static 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
121static 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
127static 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
134static 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
141static 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
146static 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
153static 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
164static 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
170static 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
177static inline bool
178fib_rule_port_is_range(const struct fib_rule_port_range *range)
179{
180	return range->start != range->end;
181}
182
183static 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
190struct fib_rules_ops *fib_rules_register(const struct fib_rules_ops *,
191					 struct net *);
192void fib_rules_unregister(struct fib_rules_ops *);
193
194int fib_rules_lookup(struct fib_rules_ops *, struct flowi *, int flags,
195		     struct fib_lookup_arg *);
196int fib_default_rule_add(struct fib_rules_ops *, u32 pref, u32 table);
197bool fib_rule_matchall(const struct fib_rule *rule);
198int fib_rules_dump(struct net *net, struct notifier_block *nb, int family,
199		   struct netlink_ext_ack *extack);
200unsigned int fib_rules_seq_read(const struct net *net, int family);
201
202int fib_newrule(struct net *net, struct sk_buff *skb, struct nlmsghdr *nlh,
203		struct netlink_ext_ack *extack, bool rtnl_held);
204int fib_delrule(struct net *net, struct sk_buff *skb, struct nlmsghdr *nlh,
205		struct netlink_ext_ack *extack, bool rtnl_held);
206
207INDIRECT_CALLABLE_DECLARE(int fib6_rule_match(struct fib_rule *rule,
208					    struct flowi *fl, int flags));
209INDIRECT_CALLABLE_DECLARE(int fib4_rule_match(struct fib_rule *rule,
210					    struct flowi *fl, int flags));
211
212INDIRECT_CALLABLE_DECLARE(int fib6_rule_action(struct fib_rule *rule,
213			    struct flowi *flp, int flags,
214			    struct fib_lookup_arg *arg));
215INDIRECT_CALLABLE_DECLARE(int fib4_rule_action(struct fib_rule *rule,
216			    struct flowi *flp, int flags,
217			    struct fib_lookup_arg *arg));
218
219INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
220						int flags,
221						struct fib_lookup_arg *arg));
222INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
223						int flags,
224						struct fib_lookup_arg *arg));
225#endif