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 * Version: $Id: fib_rules.c,v 1.17 2001/10/31 21:55:54 davem Exp $
10 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 * Rani Assaf : local_rule cannot be deleted
19 * Marc Boucher : routing by fwmark
22 #include <linux/config.h>
23 #include <asm/uaccess.h>
24 #include <asm/system.h>
25 #include <linux/bitops.h>
26 #include <linux/types.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
30 #include <linux/string.h>
31 #include <linux/socket.h>
32 #include <linux/sockios.h>
33 #include <linux/errno.h>
35 #include <linux/inet.h>
36 #include <linux/inetdevice.h>
37 #include <linux/netdevice.h>
38 #include <linux/if_arp.h>
39 #include <linux/proc_fs.h>
40 #include <linux/skbuff.h>
41 #include <linux/netlink.h>
42 #include <linux/init.h>
43 #include <linux/list.h>
44 #include <linux/rcupdate.h>
47 #include <net/protocol.h>
48 #include <net/route.h>
51 #include <net/ip_fib.h>
53 #define FRprintk(a...)
57 struct hlist_node hlist
;
60 unsigned char r_table
;
61 unsigned char r_action
;
62 unsigned char r_dst_len
;
63 unsigned char r_src_len
;
71 #ifdef CONFIG_IP_ROUTE_FWMARK
75 #ifdef CONFIG_NET_CLS_ROUTE
78 char r_ifname
[IFNAMSIZ
];
83 static struct fib_rule default_rule
= {
84 .r_clntref
= ATOMIC_INIT(2),
85 .r_preference
= 0x7FFF,
86 .r_table
= RT_TABLE_DEFAULT
,
87 .r_action
= RTN_UNICAST
,
90 static struct fib_rule main_rule
= {
91 .r_clntref
= ATOMIC_INIT(2),
92 .r_preference
= 0x7FFE,
93 .r_table
= RT_TABLE_MAIN
,
94 .r_action
= RTN_UNICAST
,
97 static struct fib_rule local_rule
= {
98 .r_clntref
= ATOMIC_INIT(2),
99 .r_table
= RT_TABLE_LOCAL
,
100 .r_action
= RTN_UNICAST
,
103 static struct hlist_head fib_rules
;
105 /* writer func called from netlink -- rtnl_sem hold*/
107 int inet_rtm_delrule(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
109 struct rtattr
**rta
= arg
;
110 struct rtmsg
*rtm
= NLMSG_DATA(nlh
);
112 struct hlist_node
*node
;
115 hlist_for_each_entry(r
, node
, &fib_rules
, hlist
) {
116 if ((!rta
[RTA_SRC
-1] || memcmp(RTA_DATA(rta
[RTA_SRC
-1]), &r
->r_src
, 4) == 0) &&
117 rtm
->rtm_src_len
== r
->r_src_len
&&
118 rtm
->rtm_dst_len
== r
->r_dst_len
&&
119 (!rta
[RTA_DST
-1] || memcmp(RTA_DATA(rta
[RTA_DST
-1]), &r
->r_dst
, 4) == 0) &&
120 rtm
->rtm_tos
== r
->r_tos
&&
121 #ifdef CONFIG_IP_ROUTE_FWMARK
122 (!rta
[RTA_PROTOINFO
-1] || memcmp(RTA_DATA(rta
[RTA_PROTOINFO
-1]), &r
->r_fwmark
, 4) == 0) &&
124 (!rtm
->rtm_type
|| rtm
->rtm_type
== r
->r_action
) &&
125 (!rta
[RTA_PRIORITY
-1] || memcmp(RTA_DATA(rta
[RTA_PRIORITY
-1]), &r
->r_preference
, 4) == 0) &&
126 (!rta
[RTA_IIF
-1] || rtattr_strcmp(rta
[RTA_IIF
-1], r
->r_ifname
) == 0) &&
127 (!rtm
->rtm_table
|| (r
&& rtm
->rtm_table
== r
->r_table
))) {
129 if (r
== &local_rule
)
132 hlist_del_rcu(&r
->hlist
);
142 /* Allocate new unique table id */
144 static struct fib_table
*fib_empty_table(void)
148 for (id
= 1; id
<= RT_TABLE_MAX
; id
++)
149 if (fib_tables
[id
] == NULL
)
150 return __fib_new_table(id
);
154 static inline void fib_rule_put_rcu(struct rcu_head
*head
)
156 struct fib_rule
*r
= container_of(head
, struct fib_rule
, rcu
);
160 void fib_rule_put(struct fib_rule
*r
)
162 if (atomic_dec_and_test(&r
->r_clntref
)) {
164 call_rcu(&r
->rcu
, fib_rule_put_rcu
);
166 printk("Freeing alive rule %p\n", r
);
170 /* writer func called from netlink -- rtnl_sem hold*/
172 int inet_rtm_newrule(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
174 struct rtattr
**rta
= arg
;
175 struct rtmsg
*rtm
= NLMSG_DATA(nlh
);
176 struct fib_rule
*r
, *new_r
, *last
= NULL
;
177 struct hlist_node
*node
= NULL
;
178 unsigned char table_id
;
180 if (rtm
->rtm_src_len
> 32 || rtm
->rtm_dst_len
> 32 ||
181 (rtm
->rtm_tos
& ~IPTOS_TOS_MASK
))
184 if (rta
[RTA_IIF
-1] && RTA_PAYLOAD(rta
[RTA_IIF
-1]) > IFNAMSIZ
)
187 table_id
= rtm
->rtm_table
;
188 if (table_id
== RT_TABLE_UNSPEC
) {
189 struct fib_table
*table
;
190 if (rtm
->rtm_type
== RTN_UNICAST
) {
191 if ((table
= fib_empty_table()) == NULL
)
193 table_id
= table
->tb_id
;
197 new_r
= kmalloc(sizeof(*new_r
), GFP_KERNEL
);
200 memset(new_r
, 0, sizeof(*new_r
));
203 memcpy(&new_r
->r_src
, RTA_DATA(rta
[RTA_SRC
-1]), 4);
205 memcpy(&new_r
->r_dst
, RTA_DATA(rta
[RTA_DST
-1]), 4);
206 if (rta
[RTA_GATEWAY
-1])
207 memcpy(&new_r
->r_srcmap
, RTA_DATA(rta
[RTA_GATEWAY
-1]), 4);
208 new_r
->r_src_len
= rtm
->rtm_src_len
;
209 new_r
->r_dst_len
= rtm
->rtm_dst_len
;
210 new_r
->r_srcmask
= inet_make_mask(rtm
->rtm_src_len
);
211 new_r
->r_dstmask
= inet_make_mask(rtm
->rtm_dst_len
);
212 new_r
->r_tos
= rtm
->rtm_tos
;
213 #ifdef CONFIG_IP_ROUTE_FWMARK
214 if (rta
[RTA_PROTOINFO
-1])
215 memcpy(&new_r
->r_fwmark
, RTA_DATA(rta
[RTA_PROTOINFO
-1]), 4);
217 new_r
->r_action
= rtm
->rtm_type
;
218 new_r
->r_flags
= rtm
->rtm_flags
;
219 if (rta
[RTA_PRIORITY
-1])
220 memcpy(&new_r
->r_preference
, RTA_DATA(rta
[RTA_PRIORITY
-1]), 4);
221 new_r
->r_table
= table_id
;
222 if (rta
[RTA_IIF
-1]) {
223 struct net_device
*dev
;
224 rtattr_strlcpy(new_r
->r_ifname
, rta
[RTA_IIF
-1], IFNAMSIZ
);
225 new_r
->r_ifindex
= -1;
226 dev
= __dev_get_by_name(new_r
->r_ifname
);
228 new_r
->r_ifindex
= dev
->ifindex
;
230 #ifdef CONFIG_NET_CLS_ROUTE
232 memcpy(&new_r
->r_tclassid
, RTA_DATA(rta
[RTA_FLOW
-1]), 4);
234 r
= container_of(fib_rules
.first
, struct fib_rule
, hlist
);
236 if (!new_r
->r_preference
) {
237 if (r
&& r
->hlist
.next
!= NULL
) {
238 r
= container_of(r
->hlist
.next
, struct fib_rule
, hlist
);
240 new_r
->r_preference
= r
->r_preference
- 1;
244 hlist_for_each_entry(r
, node
, &fib_rules
, hlist
) {
245 if (r
->r_preference
> new_r
->r_preference
)
249 atomic_inc(&new_r
->r_clntref
);
252 hlist_add_after_rcu(&last
->hlist
, &new_r
->hlist
);
254 hlist_add_before_rcu(&new_r
->hlist
, &r
->hlist
);
259 #ifdef CONFIG_NET_CLS_ROUTE
260 u32
fib_rules_tclass(struct fib_result
*res
)
263 return res
->r
->r_tclassid
;
268 /* callers should hold rtnl semaphore */
270 static void fib_rules_detach(struct net_device
*dev
)
272 struct hlist_node
*node
;
275 hlist_for_each_entry(r
, node
, &fib_rules
, hlist
) {
276 if (r
->r_ifindex
== dev
->ifindex
)
282 /* callers should hold rtnl semaphore */
284 static void fib_rules_attach(struct net_device
*dev
)
286 struct hlist_node
*node
;
289 hlist_for_each_entry(r
, node
, &fib_rules
, hlist
) {
290 if (r
->r_ifindex
== -1 && strcmp(dev
->name
, r
->r_ifname
) == 0)
291 r
->r_ifindex
= dev
->ifindex
;
295 int fib_lookup(const struct flowi
*flp
, struct fib_result
*res
)
298 struct fib_rule
*r
, *policy
;
299 struct fib_table
*tb
;
300 struct hlist_node
*node
;
302 u32 daddr
= flp
->fl4_dst
;
303 u32 saddr
= flp
->fl4_src
;
305 FRprintk("Lookup: %u.%u.%u.%u <- %u.%u.%u.%u ",
306 NIPQUAD(flp
->fl4_dst
), NIPQUAD(flp
->fl4_src
));
310 hlist_for_each_entry_rcu(r
, node
, &fib_rules
, hlist
) {
311 if (((saddr
^r
->r_src
) & r
->r_srcmask
) ||
312 ((daddr
^r
->r_dst
) & r
->r_dstmask
) ||
313 (r
->r_tos
&& r
->r_tos
!= flp
->fl4_tos
) ||
314 #ifdef CONFIG_IP_ROUTE_FWMARK
315 (r
->r_fwmark
&& r
->r_fwmark
!= flp
->fl4_fwmark
) ||
317 (r
->r_ifindex
&& r
->r_ifindex
!= flp
->iif
))
320 FRprintk("tb %d r %d ", r
->r_table
, r
->r_action
);
321 switch (r
->r_action
) {
325 case RTN_UNREACHABLE
:
337 if ((tb
= fib_get_table(r
->r_table
)) == NULL
)
339 err
= tb
->tb_lookup(tb
, flp
, res
);
343 atomic_inc(&policy
->r_clntref
);
347 if (err
< 0 && err
!= -EAGAIN
) {
352 FRprintk("FAILURE\n");
357 void fib_select_default(const struct flowi
*flp
, struct fib_result
*res
)
359 if (res
->r
&& res
->r
->r_action
== RTN_UNICAST
&&
360 FIB_RES_GW(*res
) && FIB_RES_NH(*res
).nh_scope
== RT_SCOPE_LINK
) {
361 struct fib_table
*tb
;
362 if ((tb
= fib_get_table(res
->r
->r_table
)) != NULL
)
363 tb
->tb_select_default(tb
, flp
, res
);
367 static int fib_rules_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
369 struct net_device
*dev
= ptr
;
371 if (event
== NETDEV_UNREGISTER
)
372 fib_rules_detach(dev
);
373 else if (event
== NETDEV_REGISTER
)
374 fib_rules_attach(dev
);
379 static struct notifier_block fib_rules_notifier
= {
380 .notifier_call
=fib_rules_event
,
383 static __inline__
int inet_fill_rule(struct sk_buff
*skb
,
385 struct netlink_callback
*cb
,
389 struct nlmsghdr
*nlh
;
390 unsigned char *b
= skb
->tail
;
392 nlh
= NLMSG_NEW_ANSWER(skb
, cb
, RTM_NEWRULE
, sizeof(*rtm
), flags
);
393 rtm
= NLMSG_DATA(nlh
);
394 rtm
->rtm_family
= AF_INET
;
395 rtm
->rtm_dst_len
= r
->r_dst_len
;
396 rtm
->rtm_src_len
= r
->r_src_len
;
397 rtm
->rtm_tos
= r
->r_tos
;
398 #ifdef CONFIG_IP_ROUTE_FWMARK
400 RTA_PUT(skb
, RTA_PROTOINFO
, 4, &r
->r_fwmark
);
402 rtm
->rtm_table
= r
->r_table
;
403 rtm
->rtm_protocol
= 0;
405 rtm
->rtm_type
= r
->r_action
;
406 rtm
->rtm_flags
= r
->r_flags
;
409 RTA_PUT(skb
, RTA_DST
, 4, &r
->r_dst
);
411 RTA_PUT(skb
, RTA_SRC
, 4, &r
->r_src
);
413 RTA_PUT(skb
, RTA_IIF
, IFNAMSIZ
, &r
->r_ifname
);
415 RTA_PUT(skb
, RTA_PRIORITY
, 4, &r
->r_preference
);
417 RTA_PUT(skb
, RTA_GATEWAY
, 4, &r
->r_srcmap
);
418 #ifdef CONFIG_NET_CLS_ROUTE
420 RTA_PUT(skb
, RTA_FLOW
, 4, &r
->r_tclassid
);
422 nlh
->nlmsg_len
= skb
->tail
- b
;
427 skb_trim(skb
, b
- skb
->data
);
431 /* callers should hold rtnl semaphore */
433 int inet_dump_rules(struct sk_buff
*skb
, struct netlink_callback
*cb
)
436 int s_idx
= cb
->args
[0];
438 struct hlist_node
*node
;
441 hlist_for_each_entry(r
, node
, &fib_rules
, hlist
) {
445 if (inet_fill_rule(skb
, r
, cb
, NLM_F_MULTI
) < 0)
455 void __init
fib_rules_init(void)
457 INIT_HLIST_HEAD(&fib_rules
);
458 hlist_add_head(&local_rule
.hlist
, &fib_rules
);
459 hlist_add_after(&local_rule
.hlist
, &main_rule
.hlist
);
460 hlist_add_after(&main_rule
.hlist
, &default_rule
.hlist
);
461 register_netdevice_notifier(&fib_rules_notifier
);