2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * IPv4 Forwarding Information Base: policy rules.
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 * Thomas Graf <tgraf@suug.ch>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
17 * Rani Assaf : local_rule cannot be deleted
18 * Marc Boucher : routing by fwmark
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/netdevice.h>
24 #include <linux/netlink.h>
25 #include <linux/inetdevice.h>
26 #include <linux/init.h>
27 #include <linux/list.h>
28 #include <linux/rcupdate.h>
29 #include <linux/export.h>
31 #include <net/route.h>
33 #include <net/ip_fib.h>
34 #include <net/fib_rules.h>
37 struct fib_rule common
;
45 #ifdef CONFIG_IP_ROUTE_CLASSID
50 int __fib_lookup(struct net
*net
, struct flowi4
*flp
, struct fib_result
*res
)
52 struct fib_lookup_arg arg
= {
54 .flags
= FIB_LOOKUP_NOREF
,
58 err
= fib_rules_lookup(net
->ipv4
.rules_ops
, flowi4_to_flowi(flp
), 0, &arg
);
59 #ifdef CONFIG_IP_ROUTE_CLASSID
61 res
->tclassid
= ((struct fib4_rule
*)arg
.rule
)->tclassid
;
67 EXPORT_SYMBOL_GPL(__fib_lookup
);
69 static int fib4_rule_action(struct fib_rule
*rule
, struct flowi
*flp
,
70 int flags
, struct fib_lookup_arg
*arg
)
73 struct fib_table
*tbl
;
75 switch (rule
->action
) {
79 case FR_ACT_UNREACHABLE
:
87 case FR_ACT_BLACKHOLE
:
93 tbl
= fib_get_table(rule
->fr_net
, rule
->table
);
97 err
= fib_table_lookup(tbl
, &flp
->u
.ip4
, (struct fib_result
*) arg
->result
, arg
->flags
);
104 static bool fib4_rule_suppress(struct fib_rule
*rule
, struct fib_lookup_arg
*arg
)
106 struct fib_result
*result
= (struct fib_result
*) arg
->result
;
107 struct net_device
*dev
= result
->fi
->fib_dev
;
109 /* do not accept result if the route does
110 * not meet the required prefix length
112 if (result
->prefixlen
<= rule
->suppress_prefixlen
)
115 /* do not accept result if the route uses a device
116 * belonging to a forbidden interface group
118 if (rule
->suppress_ifgroup
!= -1 && dev
&& dev
->group
== rule
->suppress_ifgroup
)
124 if (!(arg
->flags
& FIB_LOOKUP_NOREF
))
125 fib_info_put(result
->fi
);
129 static int fib4_rule_match(struct fib_rule
*rule
, struct flowi
*fl
, int flags
)
131 struct fib4_rule
*r
= (struct fib4_rule
*) rule
;
132 struct flowi4
*fl4
= &fl
->u
.ip4
;
133 __be32 daddr
= fl4
->daddr
;
134 __be32 saddr
= fl4
->saddr
;
136 if (((saddr
^ r
->src
) & r
->srcmask
) ||
137 ((daddr
^ r
->dst
) & r
->dstmask
))
140 if (r
->tos
&& (r
->tos
!= fl4
->flowi4_tos
))
146 static struct fib_table
*fib_empty_table(struct net
*net
)
150 for (id
= 1; id
<= RT_TABLE_MAX
; id
++)
151 if (fib_get_table(net
, id
) == NULL
)
152 return fib_new_table(net
, id
);
156 static const struct nla_policy fib4_rule_policy
[FRA_MAX
+1] = {
158 [FRA_FLOW
] = { .type
= NLA_U32
},
161 static int fib4_rule_configure(struct fib_rule
*rule
, struct sk_buff
*skb
,
162 struct fib_rule_hdr
*frh
,
165 struct net
*net
= sock_net(skb
->sk
);
167 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
169 if (frh
->tos
& ~IPTOS_TOS_MASK
)
172 if (rule
->table
== RT_TABLE_UNSPEC
) {
173 if (rule
->action
== FR_ACT_TO_TBL
) {
174 struct fib_table
*table
;
176 table
= fib_empty_table(net
);
182 rule
->table
= table
->tb_id
;
187 rule4
->src
= nla_get_be32(tb
[FRA_SRC
]);
190 rule4
->dst
= nla_get_be32(tb
[FRA_DST
]);
192 #ifdef CONFIG_IP_ROUTE_CLASSID
194 rule4
->tclassid
= nla_get_u32(tb
[FRA_FLOW
]);
196 net
->ipv4
.fib_num_tclassid_users
++;
200 rule4
->src_len
= frh
->src_len
;
201 rule4
->srcmask
= inet_make_mask(rule4
->src_len
);
202 rule4
->dst_len
= frh
->dst_len
;
203 rule4
->dstmask
= inet_make_mask(rule4
->dst_len
);
204 rule4
->tos
= frh
->tos
;
206 net
->ipv4
.fib_has_custom_rules
= true;
212 static void fib4_rule_delete(struct fib_rule
*rule
)
214 struct net
*net
= rule
->fr_net
;
215 #ifdef CONFIG_IP_ROUTE_CLASSID
216 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
219 net
->ipv4
.fib_num_tclassid_users
--;
221 net
->ipv4
.fib_has_custom_rules
= true;
224 static int fib4_rule_compare(struct fib_rule
*rule
, struct fib_rule_hdr
*frh
,
227 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
229 if (frh
->src_len
&& (rule4
->src_len
!= frh
->src_len
))
232 if (frh
->dst_len
&& (rule4
->dst_len
!= frh
->dst_len
))
235 if (frh
->tos
&& (rule4
->tos
!= frh
->tos
))
238 #ifdef CONFIG_IP_ROUTE_CLASSID
239 if (tb
[FRA_FLOW
] && (rule4
->tclassid
!= nla_get_u32(tb
[FRA_FLOW
])))
243 if (frh
->src_len
&& (rule4
->src
!= nla_get_be32(tb
[FRA_SRC
])))
246 if (frh
->dst_len
&& (rule4
->dst
!= nla_get_be32(tb
[FRA_DST
])))
252 static int fib4_rule_fill(struct fib_rule
*rule
, struct sk_buff
*skb
,
253 struct fib_rule_hdr
*frh
)
255 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
257 frh
->dst_len
= rule4
->dst_len
;
258 frh
->src_len
= rule4
->src_len
;
259 frh
->tos
= rule4
->tos
;
261 if ((rule4
->dst_len
&&
262 nla_put_be32(skb
, FRA_DST
, rule4
->dst
)) ||
264 nla_put_be32(skb
, FRA_SRC
, rule4
->src
)))
265 goto nla_put_failure
;
266 #ifdef CONFIG_IP_ROUTE_CLASSID
267 if (rule4
->tclassid
&&
268 nla_put_u32(skb
, FRA_FLOW
, rule4
->tclassid
))
269 goto nla_put_failure
;
277 static size_t fib4_rule_nlmsg_payload(struct fib_rule
*rule
)
279 return nla_total_size(4) /* dst */
280 + nla_total_size(4) /* src */
281 + nla_total_size(4); /* flow */
284 static void fib4_rule_flush_cache(struct fib_rules_ops
*ops
)
286 rt_cache_flush(ops
->fro_net
);
289 static const struct fib_rules_ops __net_initconst fib4_rules_ops_template
= {
291 .rule_size
= sizeof(struct fib4_rule
),
292 .addr_size
= sizeof(u32
),
293 .action
= fib4_rule_action
,
294 .suppress
= fib4_rule_suppress
,
295 .match
= fib4_rule_match
,
296 .configure
= fib4_rule_configure
,
297 .delete = fib4_rule_delete
,
298 .compare
= fib4_rule_compare
,
299 .fill
= fib4_rule_fill
,
300 .default_pref
= fib_default_rule_pref
,
301 .nlmsg_payload
= fib4_rule_nlmsg_payload
,
302 .flush_cache
= fib4_rule_flush_cache
,
303 .nlgroup
= RTNLGRP_IPV4_RULE
,
304 .policy
= fib4_rule_policy
,
305 .owner
= THIS_MODULE
,
308 static int fib_default_rules_init(struct fib_rules_ops
*ops
)
312 err
= fib_default_rule_add(ops
, 0, RT_TABLE_LOCAL
, 0);
315 err
= fib_default_rule_add(ops
, 0x7FFE, RT_TABLE_MAIN
, 0);
318 err
= fib_default_rule_add(ops
, 0x7FFF, RT_TABLE_DEFAULT
, 0);
324 int __net_init
fib4_rules_init(struct net
*net
)
327 struct fib_rules_ops
*ops
;
329 ops
= fib_rules_register(&fib4_rules_ops_template
, net
);
333 err
= fib_default_rules_init(ops
);
336 net
->ipv4
.rules_ops
= ops
;
337 net
->ipv4
.fib_has_custom_rules
= false;
341 /* also cleans all rules already added */
342 fib_rules_unregister(ops
);
346 void __net_exit
fib4_rules_exit(struct net
*net
)
348 fib_rules_unregister(net
->ipv4
.rules_ops
);