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>
30 #include <net/route.h>
32 #include <net/ip_fib.h>
33 #include <net/fib_rules.h>
37 struct fib_rule common
;
45 #ifdef CONFIG_NET_CLS_ROUTE
50 #ifdef CONFIG_NET_CLS_ROUTE
51 u32
fib_rules_tclass(struct fib_result
*res
)
53 return res
->r
? ((struct fib4_rule
*) res
->r
)->tclassid
: 0;
57 int fib_lookup(struct flowi
*flp
, struct fib_result
*res
)
59 struct fib_lookup_arg arg
= {
64 err
= fib_rules_lookup(init_net
.ipv4
.rules_ops
, flp
, 0, &arg
);
70 static int fib4_rule_action(struct fib_rule
*rule
, struct flowi
*flp
,
71 int flags
, struct fib_lookup_arg
*arg
)
74 struct fib_table
*tbl
;
76 switch (rule
->action
) {
80 case FR_ACT_UNREACHABLE
:
88 case FR_ACT_BLACKHOLE
:
94 if ((tbl
= fib_get_table(&init_net
, rule
->table
)) == NULL
)
97 err
= tbl
->tb_lookup(tbl
, flp
, (struct fib_result
*) arg
->result
);
105 void fib_select_default(const struct flowi
*flp
, struct fib_result
*res
)
107 if (res
->r
&& res
->r
->action
== FR_ACT_TO_TBL
&&
108 FIB_RES_GW(*res
) && FIB_RES_NH(*res
).nh_scope
== RT_SCOPE_LINK
) {
109 struct fib_table
*tb
;
110 if ((tb
= fib_get_table(&init_net
, res
->r
->table
)) != NULL
)
111 tb
->tb_select_default(tb
, flp
, res
);
115 static int fib4_rule_match(struct fib_rule
*rule
, struct flowi
*fl
, int flags
)
117 struct fib4_rule
*r
= (struct fib4_rule
*) rule
;
118 __be32 daddr
= fl
->fl4_dst
;
119 __be32 saddr
= fl
->fl4_src
;
121 if (((saddr
^ r
->src
) & r
->srcmask
) ||
122 ((daddr
^ r
->dst
) & r
->dstmask
))
125 if (r
->tos
&& (r
->tos
!= fl
->fl4_tos
))
131 static struct fib_table
*fib_empty_table(struct net
*net
)
135 for (id
= 1; id
<= RT_TABLE_MAX
; id
++)
136 if (fib_get_table(net
, id
) == NULL
)
137 return fib_new_table(net
, id
);
141 static const struct nla_policy fib4_rule_policy
[FRA_MAX
+1] = {
143 [FRA_FLOW
] = { .type
= NLA_U32
},
146 static int fib4_rule_configure(struct fib_rule
*rule
, struct sk_buff
*skb
,
147 struct nlmsghdr
*nlh
, struct fib_rule_hdr
*frh
,
150 struct net
*net
= skb
->sk
->sk_net
;
152 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
154 if (frh
->tos
& ~IPTOS_TOS_MASK
)
157 if (rule
->table
== RT_TABLE_UNSPEC
) {
158 if (rule
->action
== FR_ACT_TO_TBL
) {
159 struct fib_table
*table
;
161 table
= fib_empty_table(net
);
167 rule
->table
= table
->tb_id
;
172 rule4
->src
= nla_get_be32(tb
[FRA_SRC
]);
175 rule4
->dst
= nla_get_be32(tb
[FRA_DST
]);
177 #ifdef CONFIG_NET_CLS_ROUTE
179 rule4
->tclassid
= nla_get_u32(tb
[FRA_FLOW
]);
182 rule4
->src_len
= frh
->src_len
;
183 rule4
->srcmask
= inet_make_mask(rule4
->src_len
);
184 rule4
->dst_len
= frh
->dst_len
;
185 rule4
->dstmask
= inet_make_mask(rule4
->dst_len
);
186 rule4
->tos
= frh
->tos
;
193 static int fib4_rule_compare(struct fib_rule
*rule
, struct fib_rule_hdr
*frh
,
196 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
198 if (frh
->src_len
&& (rule4
->src_len
!= frh
->src_len
))
201 if (frh
->dst_len
&& (rule4
->dst_len
!= frh
->dst_len
))
204 if (frh
->tos
&& (rule4
->tos
!= frh
->tos
))
207 #ifdef CONFIG_NET_CLS_ROUTE
208 if (tb
[FRA_FLOW
] && (rule4
->tclassid
!= nla_get_u32(tb
[FRA_FLOW
])))
212 if (frh
->src_len
&& (rule4
->src
!= nla_get_be32(tb
[FRA_SRC
])))
215 if (frh
->dst_len
&& (rule4
->dst
!= nla_get_be32(tb
[FRA_DST
])))
221 static int fib4_rule_fill(struct fib_rule
*rule
, struct sk_buff
*skb
,
222 struct nlmsghdr
*nlh
, struct fib_rule_hdr
*frh
)
224 struct fib4_rule
*rule4
= (struct fib4_rule
*) rule
;
226 frh
->family
= AF_INET
;
227 frh
->dst_len
= rule4
->dst_len
;
228 frh
->src_len
= rule4
->src_len
;
229 frh
->tos
= rule4
->tos
;
232 NLA_PUT_BE32(skb
, FRA_DST
, rule4
->dst
);
235 NLA_PUT_BE32(skb
, FRA_SRC
, rule4
->src
);
237 #ifdef CONFIG_NET_CLS_ROUTE
239 NLA_PUT_U32(skb
, FRA_FLOW
, rule4
->tclassid
);
247 static u32
fib4_rule_default_pref(struct fib_rules_ops
*ops
)
249 struct list_head
*pos
;
250 struct fib_rule
*rule
;
252 if (!list_empty(&ops
->rules_list
)) {
253 pos
= ops
->rules_list
.next
;
254 if (pos
->next
!= &ops
->rules_list
) {
255 rule
= list_entry(pos
->next
, struct fib_rule
, list
);
257 return rule
->pref
- 1;
264 static size_t fib4_rule_nlmsg_payload(struct fib_rule
*rule
)
266 return nla_total_size(4) /* dst */
267 + nla_total_size(4) /* src */
268 + nla_total_size(4); /* flow */
271 static void fib4_rule_flush_cache(void)
276 static struct fib_rules_ops fib4_rules_ops_template
= {
278 .rule_size
= sizeof(struct fib4_rule
),
279 .addr_size
= sizeof(u32
),
280 .action
= fib4_rule_action
,
281 .match
= fib4_rule_match
,
282 .configure
= fib4_rule_configure
,
283 .compare
= fib4_rule_compare
,
284 .fill
= fib4_rule_fill
,
285 .default_pref
= fib4_rule_default_pref
,
286 .nlmsg_payload
= fib4_rule_nlmsg_payload
,
287 .flush_cache
= fib4_rule_flush_cache
,
288 .nlgroup
= RTNLGRP_IPV4_RULE
,
289 .policy
= fib4_rule_policy
,
290 .owner
= THIS_MODULE
,
293 static int fib_default_rules_init(struct fib_rules_ops
*ops
)
297 err
= fib_default_rule_add(ops
, 0, RT_TABLE_LOCAL
, FIB_RULE_PERMANENT
);
300 err
= fib_default_rule_add(ops
, 0x7FFE, RT_TABLE_MAIN
, 0);
303 err
= fib_default_rule_add(ops
, 0x7FFF, RT_TABLE_DEFAULT
, 0);
309 int __net_init
fib4_rules_init(struct net
*net
)
312 struct fib_rules_ops
*ops
;
314 ops
= kmemdup(&fib4_rules_ops_template
, sizeof(*ops
), GFP_KERNEL
);
317 INIT_LIST_HEAD(&ops
->rules_list
);
318 fib_rules_register(net
, ops
);
320 err
= fib_default_rules_init(ops
);
323 net
->ipv4
.rules_ops
= ops
;
327 /* also cleans all rules already added */
328 fib_rules_unregister(net
, ops
);
333 void __net_exit
fib4_rules_exit(struct net
*net
)
335 fib_rules_unregister(net
, net
->ipv4
.rules_ops
);
336 kfree(net
->ipv4
.rules_ops
);