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: FIB frontend.
8 * Version: $Id: fib_frontend.c,v 1.26 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 #include <linux/module.h>
19 #include <asm/uaccess.h>
20 #include <asm/system.h>
21 #include <linux/bitops.h>
22 #include <linux/capability.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
26 #include <linux/string.h>
27 #include <linux/socket.h>
28 #include <linux/sockios.h>
29 #include <linux/errno.h>
31 #include <linux/inet.h>
32 #include <linux/inetdevice.h>
33 #include <linux/netdevice.h>
34 #include <linux/if_addr.h>
35 #include <linux/if_arp.h>
36 #include <linux/skbuff.h>
37 #include <linux/init.h>
38 #include <linux/list.h>
41 #include <net/protocol.h>
42 #include <net/route.h>
47 #include <net/ip_fib.h>
48 #include <net/rtnetlink.h>
50 #define FFprint(a...) printk(KERN_DEBUG a)
52 #ifndef CONFIG_IP_MULTIPLE_TABLES
54 static int __net_init
fib4_rules_init(struct net
*net
)
56 struct fib_table
*local_table
, *main_table
;
58 local_table
= fib_hash_init(RT_TABLE_LOCAL
);
59 if (local_table
== NULL
)
62 main_table
= fib_hash_init(RT_TABLE_MAIN
);
63 if (main_table
== NULL
)
66 hlist_add_head_rcu(&local_table
->tb_hlist
,
67 &net
->ipv4
.fib_table_hash
[TABLE_LOCAL_INDEX
]);
68 hlist_add_head_rcu(&main_table
->tb_hlist
,
69 &net
->ipv4
.fib_table_hash
[TABLE_MAIN_INDEX
]);
78 struct fib_table
*fib_new_table(struct net
*net
, u32 id
)
85 tb
= fib_get_table(net
, id
);
88 tb
= fib_hash_init(id
);
91 h
= id
& (FIB_TABLE_HASHSZ
- 1);
92 hlist_add_head_rcu(&tb
->tb_hlist
, &net
->ipv4
.fib_table_hash
[h
]);
96 struct fib_table
*fib_get_table(struct net
*net
, u32 id
)
99 struct hlist_node
*node
;
100 struct hlist_head
*head
;
105 h
= id
& (FIB_TABLE_HASHSZ
- 1);
108 head
= &net
->ipv4
.fib_table_hash
[h
];
109 hlist_for_each_entry_rcu(tb
, node
, head
, tb_hlist
) {
110 if (tb
->tb_id
== id
) {
118 #endif /* CONFIG_IP_MULTIPLE_TABLES */
120 static void fib_flush(struct net
*net
)
123 struct fib_table
*tb
;
124 struct hlist_node
*node
;
125 struct hlist_head
*head
;
128 for (h
= 0; h
< FIB_TABLE_HASHSZ
; h
++) {
129 head
= &net
->ipv4
.fib_table_hash
[h
];
130 hlist_for_each_entry(tb
, node
, head
, tb_hlist
)
131 flushed
+= tb
->tb_flush(tb
);
139 * Find the first device with a given source address.
142 struct net_device
* ip_dev_find(__be32 addr
)
144 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= addr
} } };
145 struct fib_result res
;
146 struct net_device
*dev
= NULL
;
147 struct fib_table
*local_table
;
149 #ifdef CONFIG_IP_MULTIPLE_TABLES
153 local_table
= fib_get_table(&init_net
, RT_TABLE_LOCAL
);
154 if (!local_table
|| local_table
->tb_lookup(local_table
, &fl
, &res
))
156 if (res
.type
!= RTN_LOCAL
)
158 dev
= FIB_RES_DEV(res
);
168 * Find address type as if only "dev" was present in the system. If
169 * on_dev is NULL then all interfaces are taken into consideration.
171 static inline unsigned __inet_dev_addr_type(struct net
*net
,
172 const struct net_device
*dev
,
175 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= addr
} } };
176 struct fib_result res
;
177 unsigned ret
= RTN_BROADCAST
;
178 struct fib_table
*local_table
;
180 if (ipv4_is_zeronet(addr
) || ipv4_is_badclass(addr
))
181 return RTN_BROADCAST
;
182 if (ipv4_is_multicast(addr
))
183 return RTN_MULTICAST
;
185 #ifdef CONFIG_IP_MULTIPLE_TABLES
189 local_table
= fib_get_table(net
, RT_TABLE_LOCAL
);
192 if (!local_table
->tb_lookup(local_table
, &fl
, &res
)) {
193 if (!dev
|| dev
== res
.fi
->fib_dev
)
201 unsigned int inet_addr_type(struct net
*net
, __be32 addr
)
203 return __inet_dev_addr_type(net
, NULL
, addr
);
206 unsigned int inet_dev_addr_type(struct net
*net
, const struct net_device
*dev
,
209 return __inet_dev_addr_type(net
, dev
, addr
);
212 /* Given (packet source, input interface) and optional (dst, oif, tos):
213 - (main) check, that source is valid i.e. not broadcast or our local
215 - figure out what "logical" interface this packet arrived
216 and calculate "specific destination" address.
217 - check, that packet arrived from expected physical interface.
220 int fib_validate_source(__be32 src
, __be32 dst
, u8 tos
, int oif
,
221 struct net_device
*dev
, __be32
*spec_dst
, u32
*itag
)
223 struct in_device
*in_dev
;
224 struct flowi fl
= { .nl_u
= { .ip4_u
=
229 struct fib_result res
;
235 in_dev
= __in_dev_get_rcu(dev
);
237 no_addr
= in_dev
->ifa_list
== NULL
;
238 rpf
= IN_DEV_RPFILTER(in_dev
);
245 if (fib_lookup(&fl
, &res
))
247 if (res
.type
!= RTN_UNICAST
)
249 *spec_dst
= FIB_RES_PREFSRC(res
);
250 fib_combine_itag(itag
, &res
);
251 #ifdef CONFIG_IP_ROUTE_MULTIPATH
252 if (FIB_RES_DEV(res
) == dev
|| res
.fi
->fib_nhs
> 1)
254 if (FIB_RES_DEV(res
) == dev
)
257 ret
= FIB_RES_NH(res
).nh_scope
>= RT_SCOPE_HOST
;
266 fl
.oif
= dev
->ifindex
;
269 if (fib_lookup(&fl
, &res
) == 0) {
270 if (res
.type
== RTN_UNICAST
) {
271 *spec_dst
= FIB_RES_PREFSRC(res
);
272 ret
= FIB_RES_NH(res
).nh_scope
>= RT_SCOPE_HOST
;
281 *spec_dst
= inet_select_addr(dev
, 0, RT_SCOPE_UNIVERSE
);
291 static inline __be32
sk_extract_addr(struct sockaddr
*addr
)
293 return ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
;
296 static int put_rtax(struct nlattr
*mx
, int len
, int type
, u32 value
)
300 nla
= (struct nlattr
*) ((char *) mx
+ len
);
301 nla
->nla_type
= type
;
302 nla
->nla_len
= nla_attr_size(4);
303 *(u32
*) nla_data(nla
) = value
;
305 return len
+ nla_total_size(4);
308 static int rtentry_to_fib_config(struct net
*net
, int cmd
, struct rtentry
*rt
,
309 struct fib_config
*cfg
)
314 memset(cfg
, 0, sizeof(*cfg
));
315 cfg
->fc_nlinfo
.nl_net
= net
;
317 if (rt
->rt_dst
.sa_family
!= AF_INET
)
318 return -EAFNOSUPPORT
;
321 * Check mask for validity:
322 * a) it must be contiguous.
323 * b) destination must have all host bits clear.
324 * c) if application forgot to set correct family (AF_INET),
325 * reject request unless it is absolutely clear i.e.
326 * both family and mask are zero.
329 addr
= sk_extract_addr(&rt
->rt_dst
);
330 if (!(rt
->rt_flags
& RTF_HOST
)) {
331 __be32 mask
= sk_extract_addr(&rt
->rt_genmask
);
333 if (rt
->rt_genmask
.sa_family
!= AF_INET
) {
334 if (mask
|| rt
->rt_genmask
.sa_family
)
335 return -EAFNOSUPPORT
;
338 if (bad_mask(mask
, addr
))
341 plen
= inet_mask_len(mask
);
344 cfg
->fc_dst_len
= plen
;
347 if (cmd
!= SIOCDELRT
) {
348 cfg
->fc_nlflags
= NLM_F_CREATE
;
349 cfg
->fc_protocol
= RTPROT_BOOT
;
353 cfg
->fc_priority
= rt
->rt_metric
- 1;
355 if (rt
->rt_flags
& RTF_REJECT
) {
356 cfg
->fc_scope
= RT_SCOPE_HOST
;
357 cfg
->fc_type
= RTN_UNREACHABLE
;
361 cfg
->fc_scope
= RT_SCOPE_NOWHERE
;
362 cfg
->fc_type
= RTN_UNICAST
;
366 struct net_device
*dev
;
367 char devname
[IFNAMSIZ
];
369 if (copy_from_user(devname
, rt
->rt_dev
, IFNAMSIZ
-1))
372 devname
[IFNAMSIZ
-1] = 0;
373 colon
= strchr(devname
, ':');
376 dev
= __dev_get_by_name(net
, devname
);
379 cfg
->fc_oif
= dev
->ifindex
;
381 struct in_ifaddr
*ifa
;
382 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
386 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
)
387 if (strcmp(ifa
->ifa_label
, devname
) == 0)
391 cfg
->fc_prefsrc
= ifa
->ifa_local
;
395 addr
= sk_extract_addr(&rt
->rt_gateway
);
396 if (rt
->rt_gateway
.sa_family
== AF_INET
&& addr
) {
398 if (rt
->rt_flags
& RTF_GATEWAY
&&
399 inet_addr_type(net
, addr
) == RTN_UNICAST
)
400 cfg
->fc_scope
= RT_SCOPE_UNIVERSE
;
403 if (cmd
== SIOCDELRT
)
406 if (rt
->rt_flags
& RTF_GATEWAY
&& !cfg
->fc_gw
)
409 if (cfg
->fc_scope
== RT_SCOPE_NOWHERE
)
410 cfg
->fc_scope
= RT_SCOPE_LINK
;
412 if (rt
->rt_flags
& (RTF_MTU
| RTF_WINDOW
| RTF_IRTT
)) {
416 mx
= kzalloc(3 * nla_total_size(4), GFP_KERNEL
);
420 if (rt
->rt_flags
& RTF_MTU
)
421 len
= put_rtax(mx
, len
, RTAX_ADVMSS
, rt
->rt_mtu
- 40);
423 if (rt
->rt_flags
& RTF_WINDOW
)
424 len
= put_rtax(mx
, len
, RTAX_WINDOW
, rt
->rt_window
);
426 if (rt
->rt_flags
& RTF_IRTT
)
427 len
= put_rtax(mx
, len
, RTAX_RTT
, rt
->rt_irtt
<< 3);
430 cfg
->fc_mx_len
= len
;
437 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
440 int ip_rt_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
442 struct fib_config cfg
;
447 case SIOCADDRT
: /* Add a route */
448 case SIOCDELRT
: /* Delete a route */
449 if (!capable(CAP_NET_ADMIN
))
452 if (copy_from_user(&rt
, arg
, sizeof(rt
)))
456 err
= rtentry_to_fib_config(net
, cmd
, &rt
, &cfg
);
458 struct fib_table
*tb
;
460 if (cmd
== SIOCDELRT
) {
461 tb
= fib_get_table(net
, cfg
.fc_table
);
463 err
= tb
->tb_delete(tb
, &cfg
);
467 tb
= fib_new_table(net
, cfg
.fc_table
);
469 err
= tb
->tb_insert(tb
, &cfg
);
474 /* allocated by rtentry_to_fib_config() */
483 const struct nla_policy rtm_ipv4_policy
[RTA_MAX
+1] = {
484 [RTA_DST
] = { .type
= NLA_U32
},
485 [RTA_SRC
] = { .type
= NLA_U32
},
486 [RTA_IIF
] = { .type
= NLA_U32
},
487 [RTA_OIF
] = { .type
= NLA_U32
},
488 [RTA_GATEWAY
] = { .type
= NLA_U32
},
489 [RTA_PRIORITY
] = { .type
= NLA_U32
},
490 [RTA_PREFSRC
] = { .type
= NLA_U32
},
491 [RTA_METRICS
] = { .type
= NLA_NESTED
},
492 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
493 [RTA_PROTOINFO
] = { .type
= NLA_U32
},
494 [RTA_FLOW
] = { .type
= NLA_U32
},
497 static int rtm_to_fib_config(struct net
*net
, struct sk_buff
*skb
,
498 struct nlmsghdr
*nlh
, struct fib_config
*cfg
)
504 err
= nlmsg_validate(nlh
, sizeof(*rtm
), RTA_MAX
, rtm_ipv4_policy
);
508 memset(cfg
, 0, sizeof(*cfg
));
510 rtm
= nlmsg_data(nlh
);
511 cfg
->fc_dst_len
= rtm
->rtm_dst_len
;
512 cfg
->fc_tos
= rtm
->rtm_tos
;
513 cfg
->fc_table
= rtm
->rtm_table
;
514 cfg
->fc_protocol
= rtm
->rtm_protocol
;
515 cfg
->fc_scope
= rtm
->rtm_scope
;
516 cfg
->fc_type
= rtm
->rtm_type
;
517 cfg
->fc_flags
= rtm
->rtm_flags
;
518 cfg
->fc_nlflags
= nlh
->nlmsg_flags
;
520 cfg
->fc_nlinfo
.pid
= NETLINK_CB(skb
).pid
;
521 cfg
->fc_nlinfo
.nlh
= nlh
;
522 cfg
->fc_nlinfo
.nl_net
= net
;
524 if (cfg
->fc_type
> RTN_MAX
) {
529 nlmsg_for_each_attr(attr
, nlh
, sizeof(struct rtmsg
), remaining
) {
530 switch (nla_type(attr
)) {
532 cfg
->fc_dst
= nla_get_be32(attr
);
535 cfg
->fc_oif
= nla_get_u32(attr
);
538 cfg
->fc_gw
= nla_get_be32(attr
);
541 cfg
->fc_priority
= nla_get_u32(attr
);
544 cfg
->fc_prefsrc
= nla_get_be32(attr
);
547 cfg
->fc_mx
= nla_data(attr
);
548 cfg
->fc_mx_len
= nla_len(attr
);
551 cfg
->fc_mp
= nla_data(attr
);
552 cfg
->fc_mp_len
= nla_len(attr
);
555 cfg
->fc_flow
= nla_get_u32(attr
);
558 cfg
->fc_table
= nla_get_u32(attr
);
568 static int inet_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
570 struct net
*net
= skb
->sk
->sk_net
;
571 struct fib_config cfg
;
572 struct fib_table
*tb
;
575 if (net
!= &init_net
)
578 err
= rtm_to_fib_config(net
, skb
, nlh
, &cfg
);
582 tb
= fib_get_table(net
, cfg
.fc_table
);
588 err
= tb
->tb_delete(tb
, &cfg
);
593 static int inet_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
595 struct net
*net
= skb
->sk
->sk_net
;
596 struct fib_config cfg
;
597 struct fib_table
*tb
;
600 if (net
!= &init_net
)
603 err
= rtm_to_fib_config(net
, skb
, nlh
, &cfg
);
607 tb
= fib_new_table(net
, cfg
.fc_table
);
613 err
= tb
->tb_insert(tb
, &cfg
);
618 static int inet_dump_fib(struct sk_buff
*skb
, struct netlink_callback
*cb
)
620 struct net
*net
= skb
->sk
->sk_net
;
622 unsigned int e
= 0, s_e
;
623 struct fib_table
*tb
;
624 struct hlist_node
*node
;
625 struct hlist_head
*head
;
628 if (net
!= &init_net
)
631 if (nlmsg_len(cb
->nlh
) >= sizeof(struct rtmsg
) &&
632 ((struct rtmsg
*) nlmsg_data(cb
->nlh
))->rtm_flags
& RTM_F_CLONED
)
633 return ip_rt_dump(skb
, cb
);
638 for (h
= s_h
; h
< FIB_TABLE_HASHSZ
; h
++, s_e
= 0) {
640 head
= &net
->ipv4
.fib_table_hash
[h
];
641 hlist_for_each_entry(tb
, node
, head
, tb_hlist
) {
645 memset(&cb
->args
[2], 0, sizeof(cb
->args
) -
646 2 * sizeof(cb
->args
[0]));
647 if (tb
->tb_dump(tb
, skb
, cb
) < 0)
661 /* Prepare and feed intra-kernel routing request.
662 Really, it should be netlink message, but :-( netlink
663 can be not configured, so that we feed it directly
664 to fib engine. It is legal, because all events occur
665 only when netlink is already locked.
668 static void fib_magic(int cmd
, int type
, __be32 dst
, int dst_len
, struct in_ifaddr
*ifa
)
670 struct net
*net
= ifa
->ifa_dev
->dev
->nd_net
;
671 struct fib_table
*tb
;
672 struct fib_config cfg
= {
673 .fc_protocol
= RTPROT_KERNEL
,
676 .fc_dst_len
= dst_len
,
677 .fc_prefsrc
= ifa
->ifa_local
,
678 .fc_oif
= ifa
->ifa_dev
->dev
->ifindex
,
679 .fc_nlflags
= NLM_F_CREATE
| NLM_F_APPEND
,
685 if (type
== RTN_UNICAST
)
686 tb
= fib_new_table(net
, RT_TABLE_MAIN
);
688 tb
= fib_new_table(net
, RT_TABLE_LOCAL
);
693 cfg
.fc_table
= tb
->tb_id
;
695 if (type
!= RTN_LOCAL
)
696 cfg
.fc_scope
= RT_SCOPE_LINK
;
698 cfg
.fc_scope
= RT_SCOPE_HOST
;
700 if (cmd
== RTM_NEWROUTE
)
701 tb
->tb_insert(tb
, &cfg
);
703 tb
->tb_delete(tb
, &cfg
);
706 void fib_add_ifaddr(struct in_ifaddr
*ifa
)
708 struct in_device
*in_dev
= ifa
->ifa_dev
;
709 struct net_device
*dev
= in_dev
->dev
;
710 struct in_ifaddr
*prim
= ifa
;
711 __be32 mask
= ifa
->ifa_mask
;
712 __be32 addr
= ifa
->ifa_local
;
713 __be32 prefix
= ifa
->ifa_address
&mask
;
715 if (ifa
->ifa_flags
&IFA_F_SECONDARY
) {
716 prim
= inet_ifa_byprefix(in_dev
, prefix
, mask
);
718 printk(KERN_DEBUG
"fib_add_ifaddr: bug: prim == NULL\n");
723 fib_magic(RTM_NEWROUTE
, RTN_LOCAL
, addr
, 32, prim
);
725 if (!(dev
->flags
&IFF_UP
))
728 /* Add broadcast address, if it is explicitly assigned. */
729 if (ifa
->ifa_broadcast
&& ifa
->ifa_broadcast
!= htonl(0xFFFFFFFF))
730 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, ifa
->ifa_broadcast
, 32, prim
);
732 if (!ipv4_is_zeronet(prefix
) && !(ifa
->ifa_flags
&IFA_F_SECONDARY
) &&
733 (prefix
!= addr
|| ifa
->ifa_prefixlen
< 32)) {
734 fib_magic(RTM_NEWROUTE
, dev
->flags
&IFF_LOOPBACK
? RTN_LOCAL
:
735 RTN_UNICAST
, prefix
, ifa
->ifa_prefixlen
, prim
);
737 /* Add network specific broadcasts, when it takes a sense */
738 if (ifa
->ifa_prefixlen
< 31) {
739 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, prefix
, 32, prim
);
740 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, prefix
|~mask
, 32, prim
);
745 static void fib_del_ifaddr(struct in_ifaddr
*ifa
)
747 struct in_device
*in_dev
= ifa
->ifa_dev
;
748 struct net_device
*dev
= in_dev
->dev
;
749 struct in_ifaddr
*ifa1
;
750 struct in_ifaddr
*prim
= ifa
;
751 __be32 brd
= ifa
->ifa_address
|~ifa
->ifa_mask
;
752 __be32 any
= ifa
->ifa_address
&ifa
->ifa_mask
;
759 if (!(ifa
->ifa_flags
&IFA_F_SECONDARY
))
760 fib_magic(RTM_DELROUTE
, dev
->flags
&IFF_LOOPBACK
? RTN_LOCAL
:
761 RTN_UNICAST
, any
, ifa
->ifa_prefixlen
, prim
);
763 prim
= inet_ifa_byprefix(in_dev
, any
, ifa
->ifa_mask
);
765 printk(KERN_DEBUG
"fib_del_ifaddr: bug: prim == NULL\n");
770 /* Deletion is more complicated than add.
771 We should take care of not to delete too much :-)
773 Scan address list to be sure that addresses are really gone.
776 for (ifa1
= in_dev
->ifa_list
; ifa1
; ifa1
= ifa1
->ifa_next
) {
777 if (ifa
->ifa_local
== ifa1
->ifa_local
)
779 if (ifa
->ifa_broadcast
== ifa1
->ifa_broadcast
)
781 if (brd
== ifa1
->ifa_broadcast
)
783 if (any
== ifa1
->ifa_broadcast
)
788 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, ifa
->ifa_broadcast
, 32, prim
);
790 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, brd
, 32, prim
);
792 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, any
, 32, prim
);
793 if (!(ok
&LOCAL_OK
)) {
794 fib_magic(RTM_DELROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 32, prim
);
796 /* Check, that this local address finally disappeared. */
797 if (inet_addr_type(dev
->nd_net
, ifa
->ifa_local
) != RTN_LOCAL
) {
798 /* And the last, but not the least thing.
799 We must flush stray FIB entries.
801 First of all, we scan fib_info list searching
802 for stray nexthop entries, then ignite fib_flush.
804 if (fib_sync_down(ifa
->ifa_local
, NULL
, 0))
805 fib_flush(dev
->nd_net
);
814 static void nl_fib_lookup(struct fib_result_nl
*frn
, struct fib_table
*tb
)
817 struct fib_result res
;
818 struct flowi fl
= { .mark
= frn
->fl_mark
,
819 .nl_u
= { .ip4_u
= { .daddr
= frn
->fl_addr
,
821 .scope
= frn
->fl_scope
} } };
823 #ifdef CONFIG_IP_MULTIPLE_TABLES
831 frn
->tb_id
= tb
->tb_id
;
832 frn
->err
= tb
->tb_lookup(tb
, &fl
, &res
);
835 frn
->prefixlen
= res
.prefixlen
;
836 frn
->nh_sel
= res
.nh_sel
;
837 frn
->type
= res
.type
;
838 frn
->scope
= res
.scope
;
845 static void nl_fib_input(struct sk_buff
*skb
)
848 struct fib_result_nl
*frn
;
849 struct nlmsghdr
*nlh
;
850 struct fib_table
*tb
;
853 net
= skb
->sk
->sk_net
;
854 nlh
= nlmsg_hdr(skb
);
855 if (skb
->len
< NLMSG_SPACE(0) || skb
->len
< nlh
->nlmsg_len
||
856 nlh
->nlmsg_len
< NLMSG_LENGTH(sizeof(*frn
)))
859 skb
= skb_clone(skb
, GFP_KERNEL
);
862 nlh
= nlmsg_hdr(skb
);
864 frn
= (struct fib_result_nl
*) NLMSG_DATA(nlh
);
865 tb
= fib_get_table(net
, frn
->tb_id_in
);
867 nl_fib_lookup(frn
, tb
);
869 pid
= NETLINK_CB(skb
).pid
; /* pid of sending process */
870 NETLINK_CB(skb
).pid
= 0; /* from kernel */
871 NETLINK_CB(skb
).dst_group
= 0; /* unicast */
872 netlink_unicast(net
->ipv4
.fibnl
, skb
, pid
, MSG_DONTWAIT
);
875 static int nl_fib_lookup_init(struct net
*net
)
878 sk
= netlink_kernel_create(net
, NETLINK_FIB_LOOKUP
, 0,
879 nl_fib_input
, NULL
, THIS_MODULE
);
881 return -EAFNOSUPPORT
;
882 /* Don't hold an extra reference on the namespace */
884 net
->ipv4
.fibnl
= sk
;
888 static void nl_fib_lookup_exit(struct net
*net
)
890 /* At the last minute lie and say this is a socket for the
891 * initial network namespace. So the socket will be safe to free.
893 net
->ipv4
.fibnl
->sk_net
= get_net(&init_net
);
894 sock_put(net
->ipv4
.fibnl
);
897 static void fib_disable_ip(struct net_device
*dev
, int force
)
899 if (fib_sync_down(0, dev
, force
))
900 fib_flush(dev
->nd_net
);
905 static int fib_inetaddr_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
907 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
912 #ifdef CONFIG_IP_ROUTE_MULTIPATH
913 fib_sync_up(ifa
->ifa_dev
->dev
);
919 if (ifa
->ifa_dev
->ifa_list
== NULL
) {
920 /* Last address was deleted from this interface.
923 fib_disable_ip(ifa
->ifa_dev
->dev
, 1);
932 static int fib_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
934 struct net_device
*dev
= ptr
;
935 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
937 if (dev
->nd_net
!= &init_net
)
940 if (event
== NETDEV_UNREGISTER
) {
941 fib_disable_ip(dev
, 2);
952 } endfor_ifa(in_dev
);
953 #ifdef CONFIG_IP_ROUTE_MULTIPATH
959 fib_disable_ip(dev
, 0);
961 case NETDEV_CHANGEMTU
:
969 static struct notifier_block fib_inetaddr_notifier
= {
970 .notifier_call
=fib_inetaddr_event
,
973 static struct notifier_block fib_netdev_notifier
= {
974 .notifier_call
=fib_netdev_event
,
977 static int __net_init
ip_fib_net_init(struct net
*net
)
981 net
->ipv4
.fib_table_hash
= kzalloc(
982 sizeof(struct hlist_head
)*FIB_TABLE_HASHSZ
, GFP_KERNEL
);
983 if (net
->ipv4
.fib_table_hash
== NULL
)
986 for (i
= 0; i
< FIB_TABLE_HASHSZ
; i
++)
987 INIT_HLIST_HEAD(&net
->ipv4
.fib_table_hash
[i
]);
989 return fib4_rules_init(net
);
992 static void __net_exit
ip_fib_net_exit(struct net
*net
)
996 #ifdef CONFIG_IP_MULTIPLE_TABLES
997 fib4_rules_exit(net
);
1000 for (i
= 0; i
< FIB_TABLE_HASHSZ
; i
++) {
1001 struct fib_table
*tb
;
1002 struct hlist_head
*head
;
1003 struct hlist_node
*node
, *tmp
;
1005 head
= &net
->ipv4
.fib_table_hash
[i
];
1006 hlist_for_each_entry_safe(tb
, node
, tmp
, head
, tb_hlist
) {
1012 kfree(net
->ipv4
.fib_table_hash
);
1015 static int __net_init
fib_net_init(struct net
*net
)
1020 if (net
!= &init_net
)
1023 error
= ip_fib_net_init(net
);
1026 error
= nl_fib_lookup_init(net
);
1029 error
= fib_proc_init(net
);
1036 nl_fib_lookup_exit(net
);
1038 ip_fib_net_exit(net
);
1042 static void __net_exit
fib_net_exit(struct net
*net
)
1045 nl_fib_lookup_exit(net
);
1046 ip_fib_net_exit(net
);
1049 static struct pernet_operations fib_net_ops
= {
1050 .init
= fib_net_init
,
1051 .exit
= fib_net_exit
,
1054 void __init
ip_fib_init(void)
1056 rtnl_register(PF_INET
, RTM_NEWROUTE
, inet_rtm_newroute
, NULL
);
1057 rtnl_register(PF_INET
, RTM_DELROUTE
, inet_rtm_delroute
, NULL
);
1058 rtnl_register(PF_INET
, RTM_GETROUTE
, NULL
, inet_dump_fib
);
1060 register_pernet_subsys(&fib_net_ops
);
1061 register_netdevice_notifier(&fib_netdev_notifier
);
1062 register_inetaddr_notifier(&fib_inetaddr_notifier
);
1065 EXPORT_SYMBOL(inet_addr_type
);
1066 EXPORT_SYMBOL(inet_dev_addr_type
);
1067 EXPORT_SYMBOL(ip_dev_find
);