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>
25 #include <linux/sched.h>
27 #include <linux/string.h>
28 #include <linux/socket.h>
29 #include <linux/sockios.h>
30 #include <linux/errno.h>
32 #include <linux/inet.h>
33 #include <linux/inetdevice.h>
34 #include <linux/netdevice.h>
35 #include <linux/if_addr.h>
36 #include <linux/if_arp.h>
37 #include <linux/skbuff.h>
38 #include <linux/netlink.h>
39 #include <linux/init.h>
40 #include <linux/list.h>
43 #include <net/protocol.h>
44 #include <net/route.h>
49 #include <net/ip_fib.h>
51 #define FFprint(a...) printk(KERN_DEBUG a)
53 #ifndef CONFIG_IP_MULTIPLE_TABLES
55 struct fib_table *ip_fib_local_table;
56 struct fib_table *ip_fib_main_table;
58 #define FIB_TABLE_HASHSZ 1
59 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
63 #define FIB_TABLE_HASHSZ 256
64 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
66 struct fib_table *fib_new_table(u32 id)
73 tb = fib_get_table(id);
76 tb = fib_hash_init(id);
79 h = id & (FIB_TABLE_HASHSZ - 1);
80 hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
84 struct fib_table *fib_get_table(u32 id)
87 struct hlist_node *node;
92 h = id & (FIB_TABLE_HASHSZ - 1);
94 hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
95 if (tb->tb_id == id) {
103 #endif /* CONFIG_IP_MULTIPLE_TABLES */
105 static void fib_flush(void)
108 struct fib_table *tb;
109 struct hlist_node *node;
112 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
113 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
114 flushed += tb->tb_flush(tb);
122 * Find the first device with a given source address.
125 struct net_device * ip_dev_find(u32 addr)
127 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
128 struct fib_result res;
129 struct net_device *dev = NULL;
131 #ifdef CONFIG_IP_MULTIPLE_TABLES
135 if (!ip_fib_local_table ||
136 ip_fib_local_table->tb_lookup(ip_fib_local_table, &fl, &res))
138 if (res.type != RTN_LOCAL)
140 dev = FIB_RES_DEV(res);
149 unsigned inet_addr_type(u32 addr)
151 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
152 struct fib_result res;
153 unsigned ret = RTN_BROADCAST;
155 if (ZERONET(addr) || BADCLASS(addr))
156 return RTN_BROADCAST;
158 return RTN_MULTICAST;
160 #ifdef CONFIG_IP_MULTIPLE_TABLES
164 if (ip_fib_local_table) {
166 if (!ip_fib_local_table->tb_lookup(ip_fib_local_table,
175 /* Given (packet source, input interface) and optional (dst, oif, tos):
176 - (main) check, that source is valid i.e. not broadcast or our local
178 - figure out what "logical" interface this packet arrived
179 and calculate "specific destination" address.
180 - check, that packet arrived from expected physical interface.
183 int fib_validate_source(u32 src, u32 dst, u8 tos, int oif,
184 struct net_device *dev, u32 *spec_dst, u32 *itag)
186 struct in_device *in_dev;
187 struct flowi fl = { .nl_u = { .ip4_u =
192 struct fib_result res;
198 in_dev = __in_dev_get_rcu(dev);
200 no_addr = in_dev->ifa_list == NULL;
201 rpf = IN_DEV_RPFILTER(in_dev);
208 if (fib_lookup(&fl, &res))
210 if (res.type != RTN_UNICAST)
212 *spec_dst = FIB_RES_PREFSRC(res);
213 fib_combine_itag(itag, &res);
214 #ifdef CONFIG_IP_ROUTE_MULTIPATH
215 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
217 if (FIB_RES_DEV(res) == dev)
220 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
229 fl.oif = dev->ifindex;
232 if (fib_lookup(&fl, &res) == 0) {
233 if (res.type == RTN_UNICAST) {
234 *spec_dst = FIB_RES_PREFSRC(res);
235 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
244 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
254 #ifndef CONFIG_IP_NOSIOCRT
257 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
260 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
271 case SIOCADDRT: /* Add a route */
272 case SIOCDELRT: /* Delete a route */
273 if (!capable(CAP_NET_ADMIN))
275 if (copy_from_user(&r, arg, sizeof(struct rtentry)))
278 err = fib_convert_rtentry(cmd, &req.nlh, &req.rtm, &rta, &r);
280 if (cmd == SIOCDELRT) {
281 struct fib_table *tb = fib_get_table(req.rtm.rtm_table);
284 err = tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
286 struct fib_table *tb = fib_new_table(req.rtm.rtm_table);
289 err = tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
301 int ip_rt_ioctl(unsigned int cmd, void *arg)
308 static int inet_check_attr(struct rtmsg *r, struct rtattr **rta)
312 for (i=1; i<=RTA_MAX; i++, rta++) {
313 struct rtattr *attr = *rta;
315 if (RTA_PAYLOAD(attr) < 4)
317 if (i != RTA_MULTIPATH && i != RTA_METRICS &&
319 *rta = (struct rtattr*)RTA_DATA(attr);
325 int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
327 struct fib_table * tb;
328 struct rtattr **rta = arg;
329 struct rtmsg *r = NLMSG_DATA(nlh);
331 if (inet_check_attr(r, rta))
334 tb = fib_get_table(rtm_get_table(rta, r->rtm_table));
336 return tb->tb_delete(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
340 int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
342 struct fib_table * tb;
343 struct rtattr **rta = arg;
344 struct rtmsg *r = NLMSG_DATA(nlh);
346 if (inet_check_attr(r, rta))
349 tb = fib_new_table(rtm_get_table(rta, r->rtm_table));
351 return tb->tb_insert(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
355 int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
358 unsigned int e = 0, s_e;
359 struct fib_table *tb;
360 struct hlist_node *node;
363 if (NLMSG_PAYLOAD(cb->nlh, 0) >= sizeof(struct rtmsg) &&
364 ((struct rtmsg*)NLMSG_DATA(cb->nlh))->rtm_flags&RTM_F_CLONED)
365 return ip_rt_dump(skb, cb);
370 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
372 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
376 memset(&cb->args[2], 0, sizeof(cb->args) -
377 2 * sizeof(cb->args[0]));
378 if (tb->tb_dump(tb, skb, cb) < 0)
392 /* Prepare and feed intra-kernel routing request.
393 Really, it should be netlink message, but :-( netlink
394 can be not configured, so that we feed it directly
395 to fib engine. It is legal, because all events occur
396 only when netlink is already locked.
399 static void fib_magic(int cmd, int type, u32 dst, int dst_len, struct in_ifaddr *ifa)
401 struct fib_table * tb;
408 memset(&req.rtm, 0, sizeof(req.rtm));
409 memset(&rta, 0, sizeof(rta));
411 if (type == RTN_UNICAST)
412 tb = fib_new_table(RT_TABLE_MAIN);
414 tb = fib_new_table(RT_TABLE_LOCAL);
419 req.nlh.nlmsg_len = sizeof(req);
420 req.nlh.nlmsg_type = cmd;
421 req.nlh.nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE|NLM_F_APPEND;
422 req.nlh.nlmsg_pid = 0;
423 req.nlh.nlmsg_seq = 0;
425 req.rtm.rtm_dst_len = dst_len;
426 req.rtm.rtm_table = tb->tb_id;
427 req.rtm.rtm_protocol = RTPROT_KERNEL;
428 req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);
429 req.rtm.rtm_type = type;
432 rta.rta_prefsrc = &ifa->ifa_local;
433 rta.rta_oif = &ifa->ifa_dev->dev->ifindex;
435 if (cmd == RTM_NEWROUTE)
436 tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
438 tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
441 void fib_add_ifaddr(struct in_ifaddr *ifa)
443 struct in_device *in_dev = ifa->ifa_dev;
444 struct net_device *dev = in_dev->dev;
445 struct in_ifaddr *prim = ifa;
446 u32 mask = ifa->ifa_mask;
447 u32 addr = ifa->ifa_local;
448 u32 prefix = ifa->ifa_address&mask;
450 if (ifa->ifa_flags&IFA_F_SECONDARY) {
451 prim = inet_ifa_byprefix(in_dev, prefix, mask);
453 printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
458 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
460 if (!(dev->flags&IFF_UP))
463 /* Add broadcast address, if it is explicitly assigned. */
464 if (ifa->ifa_broadcast && ifa->ifa_broadcast != 0xFFFFFFFF)
465 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
467 if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
468 (prefix != addr || ifa->ifa_prefixlen < 32)) {
469 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
470 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
472 /* Add network specific broadcasts, when it takes a sense */
473 if (ifa->ifa_prefixlen < 31) {
474 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
475 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
480 static void fib_del_ifaddr(struct in_ifaddr *ifa)
482 struct in_device *in_dev = ifa->ifa_dev;
483 struct net_device *dev = in_dev->dev;
484 struct in_ifaddr *ifa1;
485 struct in_ifaddr *prim = ifa;
486 u32 brd = ifa->ifa_address|~ifa->ifa_mask;
487 u32 any = ifa->ifa_address&ifa->ifa_mask;
494 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
495 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
496 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
498 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
500 printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
505 /* Deletion is more complicated than add.
506 We should take care of not to delete too much :-)
508 Scan address list to be sure that addresses are really gone.
511 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
512 if (ifa->ifa_local == ifa1->ifa_local)
514 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
516 if (brd == ifa1->ifa_broadcast)
518 if (any == ifa1->ifa_broadcast)
523 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
525 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
527 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
528 if (!(ok&LOCAL_OK)) {
529 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
531 /* Check, that this local address finally disappeared. */
532 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
533 /* And the last, but not the least thing.
534 We must flush stray FIB entries.
536 First of all, we scan fib_info list searching
537 for stray nexthop entries, then ignite fib_flush.
539 if (fib_sync_down(ifa->ifa_local, NULL, 0))
549 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
552 struct fib_result res;
553 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
554 .fwmark = frn->fl_fwmark,
556 .scope = frn->fl_scope } } };
560 frn->tb_id = tb->tb_id;
561 frn->err = tb->tb_lookup(tb, &fl, &res);
564 frn->prefixlen = res.prefixlen;
565 frn->nh_sel = res.nh_sel;
566 frn->type = res.type;
567 frn->scope = res.scope;
573 static void nl_fib_input(struct sock *sk, int len)
575 struct sk_buff *skb = NULL;
576 struct nlmsghdr *nlh = NULL;
577 struct fib_result_nl *frn;
579 struct fib_table *tb;
581 skb = skb_dequeue(&sk->sk_receive_queue);
582 nlh = (struct nlmsghdr *)skb->data;
583 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
584 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) {
589 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
590 tb = fib_get_table(frn->tb_id_in);
592 nl_fib_lookup(frn, tb);
594 pid = nlh->nlmsg_pid; /*pid of sending process */
595 NETLINK_CB(skb).pid = 0; /* from kernel */
596 NETLINK_CB(skb).dst_pid = pid;
597 NETLINK_CB(skb).dst_group = 0; /* unicast */
598 netlink_unicast(sk, skb, pid, MSG_DONTWAIT);
601 static void nl_fib_lookup_init(void)
603 netlink_kernel_create(NETLINK_FIB_LOOKUP, 0, nl_fib_input, THIS_MODULE);
606 static void fib_disable_ip(struct net_device *dev, int force)
608 if (fib_sync_down(0, dev, force))
614 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
616 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
621 #ifdef CONFIG_IP_ROUTE_MULTIPATH
622 fib_sync_up(ifa->ifa_dev->dev);
628 if (ifa->ifa_dev->ifa_list == NULL) {
629 /* Last address was deleted from this interface.
632 fib_disable_ip(ifa->ifa_dev->dev, 1);
641 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
643 struct net_device *dev = ptr;
644 struct in_device *in_dev = __in_dev_get_rtnl(dev);
646 if (event == NETDEV_UNREGISTER) {
647 fib_disable_ip(dev, 2);
658 } endfor_ifa(in_dev);
659 #ifdef CONFIG_IP_ROUTE_MULTIPATH
665 fib_disable_ip(dev, 0);
667 case NETDEV_CHANGEMTU:
675 static struct notifier_block fib_inetaddr_notifier = {
676 .notifier_call =fib_inetaddr_event,
679 static struct notifier_block fib_netdev_notifier = {
680 .notifier_call =fib_netdev_event,
683 void __init ip_fib_init(void)
687 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
688 INIT_HLIST_HEAD(&fib_table_hash[i]);
689 #ifndef CONFIG_IP_MULTIPLE_TABLES
690 ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
691 hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
692 ip_fib_main_table = fib_hash_init(RT_TABLE_MAIN);
693 hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
698 register_netdevice_notifier(&fib_netdev_notifier);
699 register_inetaddr_notifier(&fib_inetaddr_notifier);
700 nl_fib_lookup_init();
703 EXPORT_SYMBOL(inet_addr_type);
704 EXPORT_SYMBOL(ip_dev_find);