2 * net/core/fib_rules.c Generic Routing Rules
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation, version 2.
8 * Authors: Thomas Graf <tgraf@suug.ch>
11 #include <linux/types.h>
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <net/net_namespace.h>
18 #include <net/fib_rules.h>
19 #include <net/ip_tunnels.h>
21 static const struct fib_kuid_range fib_kuid_range_unset
= {
26 bool fib_rule_matchall(const struct fib_rule
*rule
)
28 if (rule
->iifindex
|| rule
->oifindex
|| rule
->mark
|| rule
->tun_id
||
31 if (rule
->suppress_ifgroup
!= -1 || rule
->suppress_prefixlen
!= -1)
33 if (!uid_eq(rule
->uid_range
.start
, fib_kuid_range_unset
.start
) ||
34 !uid_eq(rule
->uid_range
.end
, fib_kuid_range_unset
.end
))
38 EXPORT_SYMBOL_GPL(fib_rule_matchall
);
40 int fib_default_rule_add(struct fib_rules_ops
*ops
,
41 u32 pref
, u32 table
, u32 flags
)
45 r
= kzalloc(ops
->rule_size
, GFP_KERNEL
);
49 atomic_set(&r
->refcnt
, 1);
50 r
->action
= FR_ACT_TO_TBL
;
54 r
->fr_net
= ops
->fro_net
;
55 r
->uid_range
= fib_kuid_range_unset
;
57 r
->suppress_prefixlen
= -1;
58 r
->suppress_ifgroup
= -1;
60 /* The lock is not required here, the list in unreacheable
61 * at the moment this function is called */
62 list_add_tail(&r
->list
, &ops
->rules_list
);
65 EXPORT_SYMBOL(fib_default_rule_add
);
67 static u32
fib_default_rule_pref(struct fib_rules_ops
*ops
)
69 struct list_head
*pos
;
70 struct fib_rule
*rule
;
72 if (!list_empty(&ops
->rules_list
)) {
73 pos
= ops
->rules_list
.next
;
74 if (pos
->next
!= &ops
->rules_list
) {
75 rule
= list_entry(pos
->next
, struct fib_rule
, list
);
77 return rule
->pref
- 1;
84 static void notify_rule_change(int event
, struct fib_rule
*rule
,
85 struct fib_rules_ops
*ops
, struct nlmsghdr
*nlh
,
88 static struct fib_rules_ops
*lookup_rules_ops(struct net
*net
, int family
)
90 struct fib_rules_ops
*ops
;
93 list_for_each_entry_rcu(ops
, &net
->rules_ops
, list
) {
94 if (ops
->family
== family
) {
95 if (!try_module_get(ops
->owner
))
106 static void rules_ops_put(struct fib_rules_ops
*ops
)
109 module_put(ops
->owner
);
112 static void flush_route_cache(struct fib_rules_ops
*ops
)
114 if (ops
->flush_cache
)
115 ops
->flush_cache(ops
);
118 static int __fib_rules_register(struct fib_rules_ops
*ops
)
121 struct fib_rules_ops
*o
;
126 if (ops
->rule_size
< sizeof(struct fib_rule
))
129 if (ops
->match
== NULL
|| ops
->configure
== NULL
||
130 ops
->compare
== NULL
|| ops
->fill
== NULL
||
134 spin_lock(&net
->rules_mod_lock
);
135 list_for_each_entry(o
, &net
->rules_ops
, list
)
136 if (ops
->family
== o
->family
)
139 list_add_tail_rcu(&ops
->list
, &net
->rules_ops
);
142 spin_unlock(&net
->rules_mod_lock
);
147 struct fib_rules_ops
*
148 fib_rules_register(const struct fib_rules_ops
*tmpl
, struct net
*net
)
150 struct fib_rules_ops
*ops
;
153 ops
= kmemdup(tmpl
, sizeof(*ops
), GFP_KERNEL
);
155 return ERR_PTR(-ENOMEM
);
157 INIT_LIST_HEAD(&ops
->rules_list
);
160 err
= __fib_rules_register(ops
);
168 EXPORT_SYMBOL_GPL(fib_rules_register
);
170 static void fib_rules_cleanup_ops(struct fib_rules_ops
*ops
)
172 struct fib_rule
*rule
, *tmp
;
174 list_for_each_entry_safe(rule
, tmp
, &ops
->rules_list
, list
) {
175 list_del_rcu(&rule
->list
);
182 void fib_rules_unregister(struct fib_rules_ops
*ops
)
184 struct net
*net
= ops
->fro_net
;
186 spin_lock(&net
->rules_mod_lock
);
187 list_del_rcu(&ops
->list
);
188 spin_unlock(&net
->rules_mod_lock
);
190 fib_rules_cleanup_ops(ops
);
193 EXPORT_SYMBOL_GPL(fib_rules_unregister
);
195 static int uid_range_set(struct fib_kuid_range
*range
)
197 return uid_valid(range
->start
) && uid_valid(range
->end
);
200 static struct fib_kuid_range
nla_get_kuid_range(struct nlattr
**tb
)
202 struct fib_rule_uid_range
*in
;
203 struct fib_kuid_range out
;
205 in
= (struct fib_rule_uid_range
*)nla_data(tb
[FRA_UID_RANGE
]);
207 out
.start
= make_kuid(current_user_ns(), in
->start
);
208 out
.end
= make_kuid(current_user_ns(), in
->end
);
213 static int nla_put_uid_range(struct sk_buff
*skb
, struct fib_kuid_range
*range
)
215 struct fib_rule_uid_range out
= {
216 from_kuid_munged(current_user_ns(), range
->start
),
217 from_kuid_munged(current_user_ns(), range
->end
)
220 return nla_put(skb
, FRA_UID_RANGE
, sizeof(out
), &out
);
223 static int fib_rule_match(struct fib_rule
*rule
, struct fib_rules_ops
*ops
,
224 struct flowi
*fl
, int flags
,
225 struct fib_lookup_arg
*arg
)
229 if (rule
->iifindex
&& (rule
->iifindex
!= fl
->flowi_iif
))
232 if (rule
->oifindex
&& (rule
->oifindex
!= fl
->flowi_oif
))
235 if ((rule
->mark
^ fl
->flowi_mark
) & rule
->mark_mask
)
238 if (rule
->tun_id
&& (rule
->tun_id
!= fl
->flowi_tun_key
.tun_id
))
241 if (rule
->l3mdev
&& !l3mdev_fib_rule_match(rule
->fr_net
, fl
, arg
))
244 if (uid_lt(fl
->flowi_uid
, rule
->uid_range
.start
) ||
245 uid_gt(fl
->flowi_uid
, rule
->uid_range
.end
))
248 ret
= ops
->match(rule
, fl
, flags
);
250 return (rule
->flags
& FIB_RULE_INVERT
) ? !ret
: ret
;
253 int fib_rules_lookup(struct fib_rules_ops
*ops
, struct flowi
*fl
,
254 int flags
, struct fib_lookup_arg
*arg
)
256 struct fib_rule
*rule
;
261 list_for_each_entry_rcu(rule
, &ops
->rules_list
, list
) {
263 if (!fib_rule_match(rule
, ops
, fl
, flags
, arg
))
266 if (rule
->action
== FR_ACT_GOTO
) {
267 struct fib_rule
*target
;
269 target
= rcu_dereference(rule
->ctarget
);
270 if (target
== NULL
) {
276 } else if (rule
->action
== FR_ACT_NOP
)
279 err
= ops
->action(rule
, fl
, flags
, arg
);
281 if (!err
&& ops
->suppress
&& ops
->suppress(rule
, arg
))
284 if (err
!= -EAGAIN
) {
285 if ((arg
->flags
& FIB_LOOKUP_NOREF
) ||
286 likely(atomic_inc_not_zero(&rule
->refcnt
))) {
300 EXPORT_SYMBOL_GPL(fib_rules_lookup
);
302 static int validate_rulemsg(struct fib_rule_hdr
*frh
, struct nlattr
**tb
,
303 struct fib_rules_ops
*ops
)
308 if (tb
[FRA_SRC
] == NULL
||
309 frh
->src_len
> (ops
->addr_size
* 8) ||
310 nla_len(tb
[FRA_SRC
]) != ops
->addr_size
)
314 if (tb
[FRA_DST
] == NULL
||
315 frh
->dst_len
> (ops
->addr_size
* 8) ||
316 nla_len(tb
[FRA_DST
]) != ops
->addr_size
)
324 static int rule_exists(struct fib_rules_ops
*ops
, struct fib_rule_hdr
*frh
,
325 struct nlattr
**tb
, struct fib_rule
*rule
)
329 list_for_each_entry(r
, &ops
->rules_list
, list
) {
330 if (r
->action
!= rule
->action
)
333 if (r
->table
!= rule
->table
)
336 if (r
->pref
!= rule
->pref
)
339 if (memcmp(r
->iifname
, rule
->iifname
, IFNAMSIZ
))
342 if (memcmp(r
->oifname
, rule
->oifname
, IFNAMSIZ
))
345 if (r
->mark
!= rule
->mark
)
348 if (r
->mark_mask
!= rule
->mark_mask
)
351 if (r
->tun_id
!= rule
->tun_id
)
354 if (r
->fr_net
!= rule
->fr_net
)
357 if (r
->l3mdev
!= rule
->l3mdev
)
360 if (!uid_eq(r
->uid_range
.start
, rule
->uid_range
.start
) ||
361 !uid_eq(r
->uid_range
.end
, rule
->uid_range
.end
))
364 if (!ops
->compare(r
, frh
, tb
))
371 int fib_nl_newrule(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
373 struct net
*net
= sock_net(skb
->sk
);
374 struct fib_rule_hdr
*frh
= nlmsg_data(nlh
);
375 struct fib_rules_ops
*ops
= NULL
;
376 struct fib_rule
*rule
, *r
, *last
= NULL
;
377 struct nlattr
*tb
[FRA_MAX
+1];
378 int err
= -EINVAL
, unresolved
= 0;
380 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*frh
)))
383 ops
= lookup_rules_ops(net
, frh
->family
);
389 err
= nlmsg_parse(nlh
, sizeof(*frh
), tb
, FRA_MAX
, ops
->policy
, NULL
);
393 err
= validate_rulemsg(frh
, tb
, ops
);
397 rule
= kzalloc(ops
->rule_size
, GFP_KERNEL
);
404 rule
->pref
= tb
[FRA_PRIORITY
] ? nla_get_u32(tb
[FRA_PRIORITY
])
405 : fib_default_rule_pref(ops
);
407 if (tb
[FRA_IIFNAME
]) {
408 struct net_device
*dev
;
411 nla_strlcpy(rule
->iifname
, tb
[FRA_IIFNAME
], IFNAMSIZ
);
412 dev
= __dev_get_by_name(net
, rule
->iifname
);
414 rule
->iifindex
= dev
->ifindex
;
417 if (tb
[FRA_OIFNAME
]) {
418 struct net_device
*dev
;
421 nla_strlcpy(rule
->oifname
, tb
[FRA_OIFNAME
], IFNAMSIZ
);
422 dev
= __dev_get_by_name(net
, rule
->oifname
);
424 rule
->oifindex
= dev
->ifindex
;
427 if (tb
[FRA_FWMARK
]) {
428 rule
->mark
= nla_get_u32(tb
[FRA_FWMARK
]);
430 /* compatibility: if the mark value is non-zero all bits
431 * are compared unless a mask is explicitly specified.
433 rule
->mark_mask
= 0xFFFFFFFF;
437 rule
->mark_mask
= nla_get_u32(tb
[FRA_FWMASK
]);
440 rule
->tun_id
= nla_get_be64(tb
[FRA_TUN_ID
]);
442 if (tb
[FRA_L3MDEV
]) {
443 #ifdef CONFIG_NET_L3_MASTER_DEV
444 rule
->l3mdev
= nla_get_u8(tb
[FRA_L3MDEV
]);
445 if (rule
->l3mdev
!= 1)
450 rule
->action
= frh
->action
;
451 rule
->flags
= frh
->flags
;
452 rule
->table
= frh_get_table(frh
, tb
);
453 if (tb
[FRA_SUPPRESS_PREFIXLEN
])
454 rule
->suppress_prefixlen
= nla_get_u32(tb
[FRA_SUPPRESS_PREFIXLEN
]);
456 rule
->suppress_prefixlen
= -1;
458 if (tb
[FRA_SUPPRESS_IFGROUP
])
459 rule
->suppress_ifgroup
= nla_get_u32(tb
[FRA_SUPPRESS_IFGROUP
]);
461 rule
->suppress_ifgroup
= -1;
465 if (rule
->action
!= FR_ACT_GOTO
)
468 rule
->target
= nla_get_u32(tb
[FRA_GOTO
]);
469 /* Backward jumps are prohibited to avoid endless loops */
470 if (rule
->target
<= rule
->pref
)
473 list_for_each_entry(r
, &ops
->rules_list
, list
) {
474 if (r
->pref
== rule
->target
) {
475 RCU_INIT_POINTER(rule
->ctarget
, r
);
480 if (rcu_dereference_protected(rule
->ctarget
, 1) == NULL
)
482 } else if (rule
->action
== FR_ACT_GOTO
)
485 if (rule
->l3mdev
&& rule
->table
)
488 if (tb
[FRA_UID_RANGE
]) {
489 if (current_user_ns() != net
->user_ns
) {
494 rule
->uid_range
= nla_get_kuid_range(tb
);
496 if (!uid_range_set(&rule
->uid_range
) ||
497 !uid_lte(rule
->uid_range
.start
, rule
->uid_range
.end
))
500 rule
->uid_range
= fib_kuid_range_unset
;
503 if ((nlh
->nlmsg_flags
& NLM_F_EXCL
) &&
504 rule_exists(ops
, frh
, tb
, rule
)) {
509 err
= ops
->configure(rule
, skb
, frh
, tb
);
513 list_for_each_entry(r
, &ops
->rules_list
, list
) {
514 if (r
->pref
> rule
->pref
)
522 list_add_rcu(&rule
->list
, &last
->list
);
524 list_add_rcu(&rule
->list
, &ops
->rules_list
);
526 if (ops
->unresolved_rules
) {
528 * There are unresolved goto rules in the list, check if
529 * any of them are pointing to this new rule.
531 list_for_each_entry(r
, &ops
->rules_list
, list
) {
532 if (r
->action
== FR_ACT_GOTO
&&
533 r
->target
== rule
->pref
&&
534 rtnl_dereference(r
->ctarget
) == NULL
) {
535 rcu_assign_pointer(r
->ctarget
, rule
);
536 if (--ops
->unresolved_rules
== 0)
542 if (rule
->action
== FR_ACT_GOTO
)
543 ops
->nr_goto_rules
++;
546 ops
->unresolved_rules
++;
549 ip_tunnel_need_metadata();
551 notify_rule_change(RTM_NEWRULE
, rule
, ops
, nlh
, NETLINK_CB(skb
).portid
);
552 flush_route_cache(ops
);
562 EXPORT_SYMBOL_GPL(fib_nl_newrule
);
564 int fib_nl_delrule(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
566 struct net
*net
= sock_net(skb
->sk
);
567 struct fib_rule_hdr
*frh
= nlmsg_data(nlh
);
568 struct fib_rules_ops
*ops
= NULL
;
569 struct fib_rule
*rule
, *tmp
;
570 struct nlattr
*tb
[FRA_MAX
+1];
571 struct fib_kuid_range range
;
574 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*frh
)))
577 ops
= lookup_rules_ops(net
, frh
->family
);
583 err
= nlmsg_parse(nlh
, sizeof(*frh
), tb
, FRA_MAX
, ops
->policy
, NULL
);
587 err
= validate_rulemsg(frh
, tb
, ops
);
591 if (tb
[FRA_UID_RANGE
]) {
592 range
= nla_get_kuid_range(tb
);
593 if (!uid_range_set(&range
))
596 range
= fib_kuid_range_unset
;
599 list_for_each_entry(rule
, &ops
->rules_list
, list
) {
600 if (frh
->action
&& (frh
->action
!= rule
->action
))
603 if (frh_get_table(frh
, tb
) &&
604 (frh_get_table(frh
, tb
) != rule
->table
))
607 if (tb
[FRA_PRIORITY
] &&
608 (rule
->pref
!= nla_get_u32(tb
[FRA_PRIORITY
])))
611 if (tb
[FRA_IIFNAME
] &&
612 nla_strcmp(tb
[FRA_IIFNAME
], rule
->iifname
))
615 if (tb
[FRA_OIFNAME
] &&
616 nla_strcmp(tb
[FRA_OIFNAME
], rule
->oifname
))
619 if (tb
[FRA_FWMARK
] &&
620 (rule
->mark
!= nla_get_u32(tb
[FRA_FWMARK
])))
623 if (tb
[FRA_FWMASK
] &&
624 (rule
->mark_mask
!= nla_get_u32(tb
[FRA_FWMASK
])))
627 if (tb
[FRA_TUN_ID
] &&
628 (rule
->tun_id
!= nla_get_be64(tb
[FRA_TUN_ID
])))
631 if (tb
[FRA_L3MDEV
] &&
632 (rule
->l3mdev
!= nla_get_u8(tb
[FRA_L3MDEV
])))
635 if (uid_range_set(&range
) &&
636 (!uid_eq(rule
->uid_range
.start
, range
.start
) ||
637 !uid_eq(rule
->uid_range
.end
, range
.end
)))
640 if (!ops
->compare(rule
, frh
, tb
))
643 if (rule
->flags
& FIB_RULE_PERMANENT
) {
649 err
= ops
->delete(rule
);
655 ip_tunnel_unneed_metadata();
657 list_del_rcu(&rule
->list
);
659 if (rule
->action
== FR_ACT_GOTO
) {
660 ops
->nr_goto_rules
--;
661 if (rtnl_dereference(rule
->ctarget
) == NULL
)
662 ops
->unresolved_rules
--;
666 * Check if this rule is a target to any of them. If so,
667 * disable them. As this operation is eventually very
668 * expensive, it is only performed if goto rules have
669 * actually been added.
671 if (ops
->nr_goto_rules
> 0) {
672 list_for_each_entry(tmp
, &ops
->rules_list
, list
) {
673 if (rtnl_dereference(tmp
->ctarget
) == rule
) {
674 RCU_INIT_POINTER(tmp
->ctarget
, NULL
);
675 ops
->unresolved_rules
++;
680 notify_rule_change(RTM_DELRULE
, rule
, ops
, nlh
,
681 NETLINK_CB(skb
).portid
);
683 flush_route_cache(ops
);
693 EXPORT_SYMBOL_GPL(fib_nl_delrule
);
695 static inline size_t fib_rule_nlmsg_size(struct fib_rules_ops
*ops
,
696 struct fib_rule
*rule
)
698 size_t payload
= NLMSG_ALIGN(sizeof(struct fib_rule_hdr
))
699 + nla_total_size(IFNAMSIZ
) /* FRA_IIFNAME */
700 + nla_total_size(IFNAMSIZ
) /* FRA_OIFNAME */
701 + nla_total_size(4) /* FRA_PRIORITY */
702 + nla_total_size(4) /* FRA_TABLE */
703 + nla_total_size(4) /* FRA_SUPPRESS_PREFIXLEN */
704 + nla_total_size(4) /* FRA_SUPPRESS_IFGROUP */
705 + nla_total_size(4) /* FRA_FWMARK */
706 + nla_total_size(4) /* FRA_FWMASK */
707 + nla_total_size_64bit(8) /* FRA_TUN_ID */
708 + nla_total_size(sizeof(struct fib_kuid_range
));
710 if (ops
->nlmsg_payload
)
711 payload
+= ops
->nlmsg_payload(rule
);
716 static int fib_nl_fill_rule(struct sk_buff
*skb
, struct fib_rule
*rule
,
717 u32 pid
, u32 seq
, int type
, int flags
,
718 struct fib_rules_ops
*ops
)
720 struct nlmsghdr
*nlh
;
721 struct fib_rule_hdr
*frh
;
723 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*frh
), flags
);
727 frh
= nlmsg_data(nlh
);
728 frh
->family
= ops
->family
;
729 frh
->table
= rule
->table
;
730 if (nla_put_u32(skb
, FRA_TABLE
, rule
->table
))
731 goto nla_put_failure
;
732 if (nla_put_u32(skb
, FRA_SUPPRESS_PREFIXLEN
, rule
->suppress_prefixlen
))
733 goto nla_put_failure
;
736 frh
->action
= rule
->action
;
737 frh
->flags
= rule
->flags
;
739 if (rule
->action
== FR_ACT_GOTO
&&
740 rcu_access_pointer(rule
->ctarget
) == NULL
)
741 frh
->flags
|= FIB_RULE_UNRESOLVED
;
743 if (rule
->iifname
[0]) {
744 if (nla_put_string(skb
, FRA_IIFNAME
, rule
->iifname
))
745 goto nla_put_failure
;
746 if (rule
->iifindex
== -1)
747 frh
->flags
|= FIB_RULE_IIF_DETACHED
;
750 if (rule
->oifname
[0]) {
751 if (nla_put_string(skb
, FRA_OIFNAME
, rule
->oifname
))
752 goto nla_put_failure
;
753 if (rule
->oifindex
== -1)
754 frh
->flags
|= FIB_RULE_OIF_DETACHED
;
758 nla_put_u32(skb
, FRA_PRIORITY
, rule
->pref
)) ||
760 nla_put_u32(skb
, FRA_FWMARK
, rule
->mark
)) ||
761 ((rule
->mark_mask
|| rule
->mark
) &&
762 nla_put_u32(skb
, FRA_FWMASK
, rule
->mark_mask
)) ||
764 nla_put_u32(skb
, FRA_GOTO
, rule
->target
)) ||
766 nla_put_be64(skb
, FRA_TUN_ID
, rule
->tun_id
, FRA_PAD
)) ||
768 nla_put_u8(skb
, FRA_L3MDEV
, rule
->l3mdev
)) ||
769 (uid_range_set(&rule
->uid_range
) &&
770 nla_put_uid_range(skb
, &rule
->uid_range
)))
771 goto nla_put_failure
;
773 if (rule
->suppress_ifgroup
!= -1) {
774 if (nla_put_u32(skb
, FRA_SUPPRESS_IFGROUP
, rule
->suppress_ifgroup
))
775 goto nla_put_failure
;
778 if (ops
->fill(rule
, skb
, frh
) < 0)
779 goto nla_put_failure
;
785 nlmsg_cancel(skb
, nlh
);
789 static int dump_rules(struct sk_buff
*skb
, struct netlink_callback
*cb
,
790 struct fib_rules_ops
*ops
)
793 struct fib_rule
*rule
;
797 list_for_each_entry_rcu(rule
, &ops
->rules_list
, list
) {
798 if (idx
< cb
->args
[1])
801 err
= fib_nl_fill_rule(skb
, rule
, NETLINK_CB(cb
->skb
).portid
,
802 cb
->nlh
->nlmsg_seq
, RTM_NEWRULE
,
816 static int fib_nl_dumprule(struct sk_buff
*skb
, struct netlink_callback
*cb
)
818 struct net
*net
= sock_net(skb
->sk
);
819 struct fib_rules_ops
*ops
;
822 family
= rtnl_msg_family(cb
->nlh
);
823 if (family
!= AF_UNSPEC
) {
824 /* Protocol specific dump request */
825 ops
= lookup_rules_ops(net
, family
);
827 return -EAFNOSUPPORT
;
829 dump_rules(skb
, cb
, ops
);
835 list_for_each_entry_rcu(ops
, &net
->rules_ops
, list
) {
836 if (idx
< cb
->args
[0] || !try_module_get(ops
->owner
))
839 if (dump_rules(skb
, cb
, ops
) < 0)
852 static void notify_rule_change(int event
, struct fib_rule
*rule
,
853 struct fib_rules_ops
*ops
, struct nlmsghdr
*nlh
,
861 skb
= nlmsg_new(fib_rule_nlmsg_size(ops
, rule
), GFP_KERNEL
);
865 err
= fib_nl_fill_rule(skb
, rule
, pid
, nlh
->nlmsg_seq
, event
, 0, ops
);
867 /* -EMSGSIZE implies BUG in fib_rule_nlmsg_size() */
868 WARN_ON(err
== -EMSGSIZE
);
873 rtnl_notify(skb
, net
, pid
, ops
->nlgroup
, nlh
, GFP_KERNEL
);
877 rtnl_set_sk_err(net
, ops
->nlgroup
, err
);
880 static void attach_rules(struct list_head
*rules
, struct net_device
*dev
)
882 struct fib_rule
*rule
;
884 list_for_each_entry(rule
, rules
, list
) {
885 if (rule
->iifindex
== -1 &&
886 strcmp(dev
->name
, rule
->iifname
) == 0)
887 rule
->iifindex
= dev
->ifindex
;
888 if (rule
->oifindex
== -1 &&
889 strcmp(dev
->name
, rule
->oifname
) == 0)
890 rule
->oifindex
= dev
->ifindex
;
894 static void detach_rules(struct list_head
*rules
, struct net_device
*dev
)
896 struct fib_rule
*rule
;
898 list_for_each_entry(rule
, rules
, list
) {
899 if (rule
->iifindex
== dev
->ifindex
)
901 if (rule
->oifindex
== dev
->ifindex
)
907 static int fib_rules_event(struct notifier_block
*this, unsigned long event
,
910 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
911 struct net
*net
= dev_net(dev
);
912 struct fib_rules_ops
*ops
;
917 case NETDEV_REGISTER
:
918 list_for_each_entry(ops
, &net
->rules_ops
, list
)
919 attach_rules(&ops
->rules_list
, dev
);
922 case NETDEV_CHANGENAME
:
923 list_for_each_entry(ops
, &net
->rules_ops
, list
) {
924 detach_rules(&ops
->rules_list
, dev
);
925 attach_rules(&ops
->rules_list
, dev
);
929 case NETDEV_UNREGISTER
:
930 list_for_each_entry(ops
, &net
->rules_ops
, list
)
931 detach_rules(&ops
->rules_list
, dev
);
938 static struct notifier_block fib_rules_notifier
= {
939 .notifier_call
= fib_rules_event
,
942 static int __net_init
fib_rules_net_init(struct net
*net
)
944 INIT_LIST_HEAD(&net
->rules_ops
);
945 spin_lock_init(&net
->rules_mod_lock
);
949 static struct pernet_operations fib_rules_net_ops
= {
950 .init
= fib_rules_net_init
,
953 static int __init
fib_rules_init(void)
956 rtnl_register(PF_UNSPEC
, RTM_NEWRULE
, fib_nl_newrule
, NULL
, NULL
);
957 rtnl_register(PF_UNSPEC
, RTM_DELRULE
, fib_nl_delrule
, NULL
, NULL
);
958 rtnl_register(PF_UNSPEC
, RTM_GETRULE
, NULL
, fib_nl_dumprule
, NULL
);
960 err
= register_pernet_subsys(&fib_rules_net_ops
);
964 err
= register_netdevice_notifier(&fib_rules_notifier
);
966 goto fail_unregister
;
971 unregister_pernet_subsys(&fib_rules_net_ops
);
973 rtnl_unregister(PF_UNSPEC
, RTM_NEWRULE
);
974 rtnl_unregister(PF_UNSPEC
, RTM_DELRULE
);
975 rtnl_unregister(PF_UNSPEC
, RTM_GETRULE
);
979 subsys_initcall(fib_rules_init
);