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 #ifndef CONFIG_IP_MULTIPLE_TABLES
52 static int __net_init
fib4_rules_init(struct net
*net
)
54 struct fib_table
*local_table
, *main_table
;
56 local_table
= fib_hash_table(RT_TABLE_LOCAL
);
57 if (local_table
== NULL
)
60 main_table
= fib_hash_table(RT_TABLE_MAIN
);
61 if (main_table
== NULL
)
64 hlist_add_head_rcu(&local_table
->tb_hlist
,
65 &net
->ipv4
.fib_table_hash
[TABLE_LOCAL_INDEX
]);
66 hlist_add_head_rcu(&main_table
->tb_hlist
,
67 &net
->ipv4
.fib_table_hash
[TABLE_MAIN_INDEX
]);
76 struct fib_table
*fib_new_table(struct net
*net
, u32 id
)
83 tb
= fib_get_table(net
, id
);
87 tb
= fib_hash_table(id
);
90 h
= id
& (FIB_TABLE_HASHSZ
- 1);
91 hlist_add_head_rcu(&tb
->tb_hlist
, &net
->ipv4
.fib_table_hash
[h
]);
95 struct fib_table
*fib_get_table(struct net
*net
, u32 id
)
98 struct hlist_node
*node
;
99 struct hlist_head
*head
;
104 h
= id
& (FIB_TABLE_HASHSZ
- 1);
107 head
= &net
->ipv4
.fib_table_hash
[h
];
108 hlist_for_each_entry_rcu(tb
, node
, head
, tb_hlist
) {
109 if (tb
->tb_id
== id
) {
117 #endif /* CONFIG_IP_MULTIPLE_TABLES */
119 static void fib_flush(struct net
*net
)
122 struct fib_table
*tb
;
123 struct hlist_node
*node
;
124 struct hlist_head
*head
;
127 for (h
= 0; h
< FIB_TABLE_HASHSZ
; h
++) {
128 head
= &net
->ipv4
.fib_table_hash
[h
];
129 hlist_for_each_entry(tb
, node
, head
, tb_hlist
)
130 flushed
+= tb
->tb_flush(tb
);
138 * Find the first device with a given source address.
141 struct net_device
* ip_dev_find(__be32 addr
)
143 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= addr
} } };
144 struct fib_result res
;
145 struct net_device
*dev
= NULL
;
146 struct fib_table
*local_table
;
148 #ifdef CONFIG_IP_MULTIPLE_TABLES
152 local_table
= fib_get_table(&init_net
, RT_TABLE_LOCAL
);
153 if (!local_table
|| local_table
->tb_lookup(local_table
, &fl
, &res
))
155 if (res
.type
!= RTN_LOCAL
)
157 dev
= FIB_RES_DEV(res
);
167 * Find address type as if only "dev" was present in the system. If
168 * on_dev is NULL then all interfaces are taken into consideration.
170 static inline unsigned __inet_dev_addr_type(struct net
*net
,
171 const struct net_device
*dev
,
174 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= addr
} } };
175 struct fib_result res
;
176 unsigned ret
= RTN_BROADCAST
;
177 struct fib_table
*local_table
;
179 if (ipv4_is_zeronet(addr
) || ipv4_is_badclass(addr
))
180 return RTN_BROADCAST
;
181 if (ipv4_is_multicast(addr
))
182 return RTN_MULTICAST
;
184 #ifdef CONFIG_IP_MULTIPLE_TABLES
188 local_table
= fib_get_table(net
, RT_TABLE_LOCAL
);
191 if (!local_table
->tb_lookup(local_table
, &fl
, &res
)) {
192 if (!dev
|| dev
== res
.fi
->fib_dev
)
200 unsigned int inet_addr_type(struct net
*net
, __be32 addr
)
202 return __inet_dev_addr_type(net
, NULL
, addr
);
205 unsigned int inet_dev_addr_type(struct net
*net
, const struct net_device
*dev
,
208 return __inet_dev_addr_type(net
, dev
, addr
);
211 /* Given (packet source, input interface) and optional (dst, oif, tos):
212 - (main) check, that source is valid i.e. not broadcast or our local
214 - figure out what "logical" interface this packet arrived
215 and calculate "specific destination" address.
216 - check, that packet arrived from expected physical interface.
219 int fib_validate_source(__be32 src
, __be32 dst
, u8 tos
, int oif
,
220 struct net_device
*dev
, __be32
*spec_dst
, u32
*itag
)
222 struct in_device
*in_dev
;
223 struct flowi fl
= { .nl_u
= { .ip4_u
=
228 struct fib_result res
;
234 in_dev
= __in_dev_get_rcu(dev
);
236 no_addr
= in_dev
->ifa_list
== NULL
;
237 rpf
= IN_DEV_RPFILTER(in_dev
);
244 if (fib_lookup(&fl
, &res
))
246 if (res
.type
!= RTN_UNICAST
)
248 *spec_dst
= FIB_RES_PREFSRC(res
);
249 fib_combine_itag(itag
, &res
);
250 #ifdef CONFIG_IP_ROUTE_MULTIPATH
251 if (FIB_RES_DEV(res
) == dev
|| res
.fi
->fib_nhs
> 1)
253 if (FIB_RES_DEV(res
) == dev
)
256 ret
= FIB_RES_NH(res
).nh_scope
>= RT_SCOPE_HOST
;
265 fl
.oif
= dev
->ifindex
;
268 if (fib_lookup(&fl
, &res
) == 0) {
269 if (res
.type
== RTN_UNICAST
) {
270 *spec_dst
= FIB_RES_PREFSRC(res
);
271 ret
= FIB_RES_NH(res
).nh_scope
>= RT_SCOPE_HOST
;
280 *spec_dst
= inet_select_addr(dev
, 0, RT_SCOPE_UNIVERSE
);
290 static inline __be32
sk_extract_addr(struct sockaddr
*addr
)
292 return ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
;
295 static int put_rtax(struct nlattr
*mx
, int len
, int type
, u32 value
)
299 nla
= (struct nlattr
*) ((char *) mx
+ len
);
300 nla
->nla_type
= type
;
301 nla
->nla_len
= nla_attr_size(4);
302 *(u32
*) nla_data(nla
) = value
;
304 return len
+ nla_total_size(4);
307 static int rtentry_to_fib_config(struct net
*net
, int cmd
, struct rtentry
*rt
,
308 struct fib_config
*cfg
)
313 memset(cfg
, 0, sizeof(*cfg
));
314 cfg
->fc_nlinfo
.nl_net
= net
;
316 if (rt
->rt_dst
.sa_family
!= AF_INET
)
317 return -EAFNOSUPPORT
;
320 * Check mask for validity:
321 * a) it must be contiguous.
322 * b) destination must have all host bits clear.
323 * c) if application forgot to set correct family (AF_INET),
324 * reject request unless it is absolutely clear i.e.
325 * both family and mask are zero.
328 addr
= sk_extract_addr(&rt
->rt_dst
);
329 if (!(rt
->rt_flags
& RTF_HOST
)) {
330 __be32 mask
= sk_extract_addr(&rt
->rt_genmask
);
332 if (rt
->rt_genmask
.sa_family
!= AF_INET
) {
333 if (mask
|| rt
->rt_genmask
.sa_family
)
334 return -EAFNOSUPPORT
;
337 if (bad_mask(mask
, addr
))
340 plen
= inet_mask_len(mask
);
343 cfg
->fc_dst_len
= plen
;
346 if (cmd
!= SIOCDELRT
) {
347 cfg
->fc_nlflags
= NLM_F_CREATE
;
348 cfg
->fc_protocol
= RTPROT_BOOT
;
352 cfg
->fc_priority
= rt
->rt_metric
- 1;
354 if (rt
->rt_flags
& RTF_REJECT
) {
355 cfg
->fc_scope
= RT_SCOPE_HOST
;
356 cfg
->fc_type
= RTN_UNREACHABLE
;
360 cfg
->fc_scope
= RT_SCOPE_NOWHERE
;
361 cfg
->fc_type
= RTN_UNICAST
;
365 struct net_device
*dev
;
366 char devname
[IFNAMSIZ
];
368 if (copy_from_user(devname
, rt
->rt_dev
, IFNAMSIZ
-1))
371 devname
[IFNAMSIZ
-1] = 0;
372 colon
= strchr(devname
, ':');
375 dev
= __dev_get_by_name(net
, devname
);
378 cfg
->fc_oif
= dev
->ifindex
;
380 struct in_ifaddr
*ifa
;
381 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
385 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
)
386 if (strcmp(ifa
->ifa_label
, devname
) == 0)
390 cfg
->fc_prefsrc
= ifa
->ifa_local
;
394 addr
= sk_extract_addr(&rt
->rt_gateway
);
395 if (rt
->rt_gateway
.sa_family
== AF_INET
&& addr
) {
397 if (rt
->rt_flags
& RTF_GATEWAY
&&
398 inet_addr_type(net
, addr
) == RTN_UNICAST
)
399 cfg
->fc_scope
= RT_SCOPE_UNIVERSE
;
402 if (cmd
== SIOCDELRT
)
405 if (rt
->rt_flags
& RTF_GATEWAY
&& !cfg
->fc_gw
)
408 if (cfg
->fc_scope
== RT_SCOPE_NOWHERE
)
409 cfg
->fc_scope
= RT_SCOPE_LINK
;
411 if (rt
->rt_flags
& (RTF_MTU
| RTF_WINDOW
| RTF_IRTT
)) {
415 mx
= kzalloc(3 * nla_total_size(4), GFP_KERNEL
);
419 if (rt
->rt_flags
& RTF_MTU
)
420 len
= put_rtax(mx
, len
, RTAX_ADVMSS
, rt
->rt_mtu
- 40);
422 if (rt
->rt_flags
& RTF_WINDOW
)
423 len
= put_rtax(mx
, len
, RTAX_WINDOW
, rt
->rt_window
);
425 if (rt
->rt_flags
& RTF_IRTT
)
426 len
= put_rtax(mx
, len
, RTAX_RTT
, rt
->rt_irtt
<< 3);
429 cfg
->fc_mx_len
= len
;
436 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
439 int ip_rt_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
441 struct fib_config cfg
;
446 case SIOCADDRT
: /* Add a route */
447 case SIOCDELRT
: /* Delete a route */
448 if (!capable(CAP_NET_ADMIN
))
451 if (copy_from_user(&rt
, arg
, sizeof(rt
)))
455 err
= rtentry_to_fib_config(net
, cmd
, &rt
, &cfg
);
457 struct fib_table
*tb
;
459 if (cmd
== SIOCDELRT
) {
460 tb
= fib_get_table(net
, cfg
.fc_table
);
462 err
= tb
->tb_delete(tb
, &cfg
);
466 tb
= fib_new_table(net
, cfg
.fc_table
);
468 err
= tb
->tb_insert(tb
, &cfg
);
473 /* allocated by rtentry_to_fib_config() */
482 const struct nla_policy rtm_ipv4_policy
[RTA_MAX
+1] = {
483 [RTA_DST
] = { .type
= NLA_U32
},
484 [RTA_SRC
] = { .type
= NLA_U32
},
485 [RTA_IIF
] = { .type
= NLA_U32
},
486 [RTA_OIF
] = { .type
= NLA_U32
},
487 [RTA_GATEWAY
] = { .type
= NLA_U32
},
488 [RTA_PRIORITY
] = { .type
= NLA_U32
},
489 [RTA_PREFSRC
] = { .type
= NLA_U32
},
490 [RTA_METRICS
] = { .type
= NLA_NESTED
},
491 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
492 [RTA_PROTOINFO
] = { .type
= NLA_U32
},
493 [RTA_FLOW
] = { .type
= NLA_U32
},
496 static int rtm_to_fib_config(struct net
*net
, struct sk_buff
*skb
,
497 struct nlmsghdr
*nlh
, struct fib_config
*cfg
)
503 err
= nlmsg_validate(nlh
, sizeof(*rtm
), RTA_MAX
, rtm_ipv4_policy
);
507 memset(cfg
, 0, sizeof(*cfg
));
509 rtm
= nlmsg_data(nlh
);
510 cfg
->fc_dst_len
= rtm
->rtm_dst_len
;
511 cfg
->fc_tos
= rtm
->rtm_tos
;
512 cfg
->fc_table
= rtm
->rtm_table
;
513 cfg
->fc_protocol
= rtm
->rtm_protocol
;
514 cfg
->fc_scope
= rtm
->rtm_scope
;
515 cfg
->fc_type
= rtm
->rtm_type
;
516 cfg
->fc_flags
= rtm
->rtm_flags
;
517 cfg
->fc_nlflags
= nlh
->nlmsg_flags
;
519 cfg
->fc_nlinfo
.pid
= NETLINK_CB(skb
).pid
;
520 cfg
->fc_nlinfo
.nlh
= nlh
;
521 cfg
->fc_nlinfo
.nl_net
= net
;
523 if (cfg
->fc_type
> RTN_MAX
) {
528 nlmsg_for_each_attr(attr
, nlh
, sizeof(struct rtmsg
), remaining
) {
529 switch (nla_type(attr
)) {
531 cfg
->fc_dst
= nla_get_be32(attr
);
534 cfg
->fc_oif
= nla_get_u32(attr
);
537 cfg
->fc_gw
= nla_get_be32(attr
);
540 cfg
->fc_priority
= nla_get_u32(attr
);
543 cfg
->fc_prefsrc
= nla_get_be32(attr
);
546 cfg
->fc_mx
= nla_data(attr
);
547 cfg
->fc_mx_len
= nla_len(attr
);
550 cfg
->fc_mp
= nla_data(attr
);
551 cfg
->fc_mp_len
= nla_len(attr
);
554 cfg
->fc_flow
= nla_get_u32(attr
);
557 cfg
->fc_table
= nla_get_u32(attr
);
567 static int inet_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
569 struct net
*net
= skb
->sk
->sk_net
;
570 struct fib_config cfg
;
571 struct fib_table
*tb
;
574 err
= rtm_to_fib_config(net
, skb
, nlh
, &cfg
);
578 tb
= fib_get_table(net
, cfg
.fc_table
);
584 err
= tb
->tb_delete(tb
, &cfg
);
589 static int inet_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
* nlh
, void *arg
)
591 struct net
*net
= skb
->sk
->sk_net
;
592 struct fib_config cfg
;
593 struct fib_table
*tb
;
596 err
= rtm_to_fib_config(net
, skb
, nlh
, &cfg
);
600 tb
= fib_new_table(net
, cfg
.fc_table
);
606 err
= tb
->tb_insert(tb
, &cfg
);
611 static int inet_dump_fib(struct sk_buff
*skb
, struct netlink_callback
*cb
)
613 struct net
*net
= skb
->sk
->sk_net
;
615 unsigned int e
= 0, s_e
;
616 struct fib_table
*tb
;
617 struct hlist_node
*node
;
618 struct hlist_head
*head
;
621 if (nlmsg_len(cb
->nlh
) >= sizeof(struct rtmsg
) &&
622 ((struct rtmsg
*) nlmsg_data(cb
->nlh
))->rtm_flags
& RTM_F_CLONED
)
623 return ip_rt_dump(skb
, cb
);
628 for (h
= s_h
; h
< FIB_TABLE_HASHSZ
; h
++, s_e
= 0) {
630 head
= &net
->ipv4
.fib_table_hash
[h
];
631 hlist_for_each_entry(tb
, node
, head
, tb_hlist
) {
635 memset(&cb
->args
[2], 0, sizeof(cb
->args
) -
636 2 * sizeof(cb
->args
[0]));
637 if (tb
->tb_dump(tb
, skb
, cb
) < 0)
651 /* Prepare and feed intra-kernel routing request.
652 Really, it should be netlink message, but :-( netlink
653 can be not configured, so that we feed it directly
654 to fib engine. It is legal, because all events occur
655 only when netlink is already locked.
658 static void fib_magic(int cmd
, int type
, __be32 dst
, int dst_len
, struct in_ifaddr
*ifa
)
660 struct net
*net
= ifa
->ifa_dev
->dev
->nd_net
;
661 struct fib_table
*tb
;
662 struct fib_config cfg
= {
663 .fc_protocol
= RTPROT_KERNEL
,
666 .fc_dst_len
= dst_len
,
667 .fc_prefsrc
= ifa
->ifa_local
,
668 .fc_oif
= ifa
->ifa_dev
->dev
->ifindex
,
669 .fc_nlflags
= NLM_F_CREATE
| NLM_F_APPEND
,
675 if (type
== RTN_UNICAST
)
676 tb
= fib_new_table(net
, RT_TABLE_MAIN
);
678 tb
= fib_new_table(net
, RT_TABLE_LOCAL
);
683 cfg
.fc_table
= tb
->tb_id
;
685 if (type
!= RTN_LOCAL
)
686 cfg
.fc_scope
= RT_SCOPE_LINK
;
688 cfg
.fc_scope
= RT_SCOPE_HOST
;
690 if (cmd
== RTM_NEWROUTE
)
691 tb
->tb_insert(tb
, &cfg
);
693 tb
->tb_delete(tb
, &cfg
);
696 void fib_add_ifaddr(struct in_ifaddr
*ifa
)
698 struct in_device
*in_dev
= ifa
->ifa_dev
;
699 struct net_device
*dev
= in_dev
->dev
;
700 struct in_ifaddr
*prim
= ifa
;
701 __be32 mask
= ifa
->ifa_mask
;
702 __be32 addr
= ifa
->ifa_local
;
703 __be32 prefix
= ifa
->ifa_address
&mask
;
705 if (ifa
->ifa_flags
&IFA_F_SECONDARY
) {
706 prim
= inet_ifa_byprefix(in_dev
, prefix
, mask
);
708 printk(KERN_WARNING
"fib_add_ifaddr: bug: prim == NULL\n");
713 fib_magic(RTM_NEWROUTE
, RTN_LOCAL
, addr
, 32, prim
);
715 if (!(dev
->flags
&IFF_UP
))
718 /* Add broadcast address, if it is explicitly assigned. */
719 if (ifa
->ifa_broadcast
&& ifa
->ifa_broadcast
!= htonl(0xFFFFFFFF))
720 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, ifa
->ifa_broadcast
, 32, prim
);
722 if (!ipv4_is_zeronet(prefix
) && !(ifa
->ifa_flags
&IFA_F_SECONDARY
) &&
723 (prefix
!= addr
|| ifa
->ifa_prefixlen
< 32)) {
724 fib_magic(RTM_NEWROUTE
, dev
->flags
&IFF_LOOPBACK
? RTN_LOCAL
:
725 RTN_UNICAST
, prefix
, ifa
->ifa_prefixlen
, prim
);
727 /* Add network specific broadcasts, when it takes a sense */
728 if (ifa
->ifa_prefixlen
< 31) {
729 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, prefix
, 32, prim
);
730 fib_magic(RTM_NEWROUTE
, RTN_BROADCAST
, prefix
|~mask
, 32, prim
);
735 static void fib_del_ifaddr(struct in_ifaddr
*ifa
)
737 struct in_device
*in_dev
= ifa
->ifa_dev
;
738 struct net_device
*dev
= in_dev
->dev
;
739 struct in_ifaddr
*ifa1
;
740 struct in_ifaddr
*prim
= ifa
;
741 __be32 brd
= ifa
->ifa_address
|~ifa
->ifa_mask
;
742 __be32 any
= ifa
->ifa_address
&ifa
->ifa_mask
;
749 if (!(ifa
->ifa_flags
&IFA_F_SECONDARY
))
750 fib_magic(RTM_DELROUTE
, dev
->flags
&IFF_LOOPBACK
? RTN_LOCAL
:
751 RTN_UNICAST
, any
, ifa
->ifa_prefixlen
, prim
);
753 prim
= inet_ifa_byprefix(in_dev
, any
, ifa
->ifa_mask
);
755 printk(KERN_WARNING
"fib_del_ifaddr: bug: prim == NULL\n");
760 /* Deletion is more complicated than add.
761 We should take care of not to delete too much :-)
763 Scan address list to be sure that addresses are really gone.
766 for (ifa1
= in_dev
->ifa_list
; ifa1
; ifa1
= ifa1
->ifa_next
) {
767 if (ifa
->ifa_local
== ifa1
->ifa_local
)
769 if (ifa
->ifa_broadcast
== ifa1
->ifa_broadcast
)
771 if (brd
== ifa1
->ifa_broadcast
)
773 if (any
== ifa1
->ifa_broadcast
)
778 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, ifa
->ifa_broadcast
, 32, prim
);
780 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, brd
, 32, prim
);
782 fib_magic(RTM_DELROUTE
, RTN_BROADCAST
, any
, 32, prim
);
783 if (!(ok
&LOCAL_OK
)) {
784 fib_magic(RTM_DELROUTE
, RTN_LOCAL
, ifa
->ifa_local
, 32, prim
);
786 /* Check, that this local address finally disappeared. */
787 if (inet_addr_type(dev
->nd_net
, ifa
->ifa_local
) != RTN_LOCAL
) {
788 /* And the last, but not the least thing.
789 We must flush stray FIB entries.
791 First of all, we scan fib_info list searching
792 for stray nexthop entries, then ignite fib_flush.
794 if (fib_sync_down(ifa
->ifa_local
, NULL
, 0))
795 fib_flush(dev
->nd_net
);
804 static void nl_fib_lookup(struct fib_result_nl
*frn
, struct fib_table
*tb
)
807 struct fib_result res
;
808 struct flowi fl
= { .mark
= frn
->fl_mark
,
809 .nl_u
= { .ip4_u
= { .daddr
= frn
->fl_addr
,
811 .scope
= frn
->fl_scope
} } };
813 #ifdef CONFIG_IP_MULTIPLE_TABLES
821 frn
->tb_id
= tb
->tb_id
;
822 frn
->err
= tb
->tb_lookup(tb
, &fl
, &res
);
825 frn
->prefixlen
= res
.prefixlen
;
826 frn
->nh_sel
= res
.nh_sel
;
827 frn
->type
= res
.type
;
828 frn
->scope
= res
.scope
;
835 static void nl_fib_input(struct sk_buff
*skb
)
838 struct fib_result_nl
*frn
;
839 struct nlmsghdr
*nlh
;
840 struct fib_table
*tb
;
843 net
= skb
->sk
->sk_net
;
844 nlh
= nlmsg_hdr(skb
);
845 if (skb
->len
< NLMSG_SPACE(0) || skb
->len
< nlh
->nlmsg_len
||
846 nlh
->nlmsg_len
< NLMSG_LENGTH(sizeof(*frn
)))
849 skb
= skb_clone(skb
, GFP_KERNEL
);
852 nlh
= nlmsg_hdr(skb
);
854 frn
= (struct fib_result_nl
*) NLMSG_DATA(nlh
);
855 tb
= fib_get_table(net
, frn
->tb_id_in
);
857 nl_fib_lookup(frn
, tb
);
859 pid
= NETLINK_CB(skb
).pid
; /* pid of sending process */
860 NETLINK_CB(skb
).pid
= 0; /* from kernel */
861 NETLINK_CB(skb
).dst_group
= 0; /* unicast */
862 netlink_unicast(net
->ipv4
.fibnl
, skb
, pid
, MSG_DONTWAIT
);
865 static int nl_fib_lookup_init(struct net
*net
)
868 sk
= netlink_kernel_create(net
, NETLINK_FIB_LOOKUP
, 0,
869 nl_fib_input
, NULL
, THIS_MODULE
);
871 return -EAFNOSUPPORT
;
872 /* Don't hold an extra reference on the namespace */
874 net
->ipv4
.fibnl
= sk
;
878 static void nl_fib_lookup_exit(struct net
*net
)
880 /* At the last minute lie and say this is a socket for the
881 * initial network namespace. So the socket will be safe to free.
883 net
->ipv4
.fibnl
->sk_net
= get_net(&init_net
);
884 sock_put(net
->ipv4
.fibnl
);
887 static void fib_disable_ip(struct net_device
*dev
, int force
)
889 if (fib_sync_down(0, dev
, force
))
890 fib_flush(dev
->nd_net
);
895 static int fib_inetaddr_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
897 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
902 #ifdef CONFIG_IP_ROUTE_MULTIPATH
903 fib_sync_up(ifa
->ifa_dev
->dev
);
909 if (ifa
->ifa_dev
->ifa_list
== NULL
) {
910 /* Last address was deleted from this interface.
913 fib_disable_ip(ifa
->ifa_dev
->dev
, 1);
922 static int fib_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
924 struct net_device
*dev
= ptr
;
925 struct in_device
*in_dev
= __in_dev_get_rtnl(dev
);
927 if (event
== NETDEV_UNREGISTER
) {
928 fib_disable_ip(dev
, 2);
939 } endfor_ifa(in_dev
);
940 #ifdef CONFIG_IP_ROUTE_MULTIPATH
946 fib_disable_ip(dev
, 0);
948 case NETDEV_CHANGEMTU
:
956 static struct notifier_block fib_inetaddr_notifier
= {
957 .notifier_call
=fib_inetaddr_event
,
960 static struct notifier_block fib_netdev_notifier
= {
961 .notifier_call
=fib_netdev_event
,
964 static int __net_init
ip_fib_net_init(struct net
*net
)
968 net
->ipv4
.fib_table_hash
= kzalloc(
969 sizeof(struct hlist_head
)*FIB_TABLE_HASHSZ
, GFP_KERNEL
);
970 if (net
->ipv4
.fib_table_hash
== NULL
)
973 for (i
= 0; i
< FIB_TABLE_HASHSZ
; i
++)
974 INIT_HLIST_HEAD(&net
->ipv4
.fib_table_hash
[i
]);
976 return fib4_rules_init(net
);
979 static void __net_exit
ip_fib_net_exit(struct net
*net
)
983 #ifdef CONFIG_IP_MULTIPLE_TABLES
984 fib4_rules_exit(net
);
987 for (i
= 0; i
< FIB_TABLE_HASHSZ
; i
++) {
988 struct fib_table
*tb
;
989 struct hlist_head
*head
;
990 struct hlist_node
*node
, *tmp
;
992 head
= &net
->ipv4
.fib_table_hash
[i
];
993 hlist_for_each_entry_safe(tb
, node
, tmp
, head
, tb_hlist
) {
999 kfree(net
->ipv4
.fib_table_hash
);
1002 static int __net_init
fib_net_init(struct net
*net
)
1006 error
= ip_fib_net_init(net
);
1009 error
= nl_fib_lookup_init(net
);
1012 error
= fib_proc_init(net
);
1019 nl_fib_lookup_exit(net
);
1021 ip_fib_net_exit(net
);
1025 static void __net_exit
fib_net_exit(struct net
*net
)
1028 nl_fib_lookup_exit(net
);
1029 ip_fib_net_exit(net
);
1032 static struct pernet_operations fib_net_ops
= {
1033 .init
= fib_net_init
,
1034 .exit
= fib_net_exit
,
1037 void __init
ip_fib_init(void)
1039 rtnl_register(PF_INET
, RTM_NEWROUTE
, inet_rtm_newroute
, NULL
);
1040 rtnl_register(PF_INET
, RTM_DELROUTE
, inet_rtm_delroute
, NULL
);
1041 rtnl_register(PF_INET
, RTM_GETROUTE
, NULL
, inet_dump_fib
);
1043 register_pernet_subsys(&fib_net_ops
);
1044 register_netdevice_notifier(&fib_netdev_notifier
);
1045 register_inetaddr_notifier(&fib_inetaddr_notifier
);
1050 EXPORT_SYMBOL(inet_addr_type
);
1051 EXPORT_SYMBOL(inet_dev_addr_type
);
1052 EXPORT_SYMBOL(ip_dev_find
);