[IPV4]: Enable use of 240/4 address space.
[linux-2.6] / net / ipv4 / fib_frontend.c
1 /*
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.
5  *
6  *              IPv4 Forwarding Information Base: FIB frontend.
7  *
8  * Version:     $Id: fib_frontend.c,v 1.26 2001/10/31 21:55:54 davem Exp $
9  *
10  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11  *
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.
16  */
17
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/mm.h>
26 #include <linux/string.h>
27 #include <linux/socket.h>
28 #include <linux/sockios.h>
29 #include <linux/errno.h>
30 #include <linux/in.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>
39
40 #include <net/ip.h>
41 #include <net/protocol.h>
42 #include <net/route.h>
43 #include <net/tcp.h>
44 #include <net/sock.h>
45 #include <net/icmp.h>
46 #include <net/arp.h>
47 #include <net/ip_fib.h>
48 #include <net/rtnetlink.h>
49
50 #ifndef CONFIG_IP_MULTIPLE_TABLES
51
52 static int __net_init fib4_rules_init(struct net *net)
53 {
54         struct fib_table *local_table, *main_table;
55
56         local_table = fib_hash_table(RT_TABLE_LOCAL);
57         if (local_table == NULL)
58                 return -ENOMEM;
59
60         main_table  = fib_hash_table(RT_TABLE_MAIN);
61         if (main_table == NULL)
62                 goto fail;
63
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]);
68         return 0;
69
70 fail:
71         kfree(local_table);
72         return -ENOMEM;
73 }
74 #else
75
76 struct fib_table *fib_new_table(struct net *net, u32 id)
77 {
78         struct fib_table *tb;
79         unsigned int h;
80
81         if (id == 0)
82                 id = RT_TABLE_MAIN;
83         tb = fib_get_table(net, id);
84         if (tb)
85                 return tb;
86
87         tb = fib_hash_table(id);
88         if (!tb)
89                 return NULL;
90         h = id & (FIB_TABLE_HASHSZ - 1);
91         hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
92         return tb;
93 }
94
95 struct fib_table *fib_get_table(struct net *net, u32 id)
96 {
97         struct fib_table *tb;
98         struct hlist_node *node;
99         struct hlist_head *head;
100         unsigned int h;
101
102         if (id == 0)
103                 id = RT_TABLE_MAIN;
104         h = id & (FIB_TABLE_HASHSZ - 1);
105
106         rcu_read_lock();
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) {
110                         rcu_read_unlock();
111                         return tb;
112                 }
113         }
114         rcu_read_unlock();
115         return NULL;
116 }
117 #endif /* CONFIG_IP_MULTIPLE_TABLES */
118
119 static void fib_flush(struct net *net)
120 {
121         int flushed = 0;
122         struct fib_table *tb;
123         struct hlist_node *node;
124         struct hlist_head *head;
125         unsigned int h;
126
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);
131         }
132
133         if (flushed)
134                 rt_cache_flush(-1);
135 }
136
137 /*
138  *      Find the first device with a given source address.
139  */
140
141 struct net_device * ip_dev_find(__be32 addr)
142 {
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;
147
148 #ifdef CONFIG_IP_MULTIPLE_TABLES
149         res.r = NULL;
150 #endif
151
152         local_table = fib_get_table(&init_net, RT_TABLE_LOCAL);
153         if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
154                 return NULL;
155         if (res.type != RTN_LOCAL)
156                 goto out;
157         dev = FIB_RES_DEV(res);
158
159         if (dev)
160                 dev_hold(dev);
161 out:
162         fib_res_put(&res);
163         return dev;
164 }
165
166 /*
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.
169  */
170 static inline unsigned __inet_dev_addr_type(struct net *net,
171                                             const struct net_device *dev,
172                                             __be32 addr)
173 {
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;
178
179         if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
180                 return RTN_BROADCAST;
181         if (ipv4_is_multicast(addr))
182                 return RTN_MULTICAST;
183
184 #ifdef CONFIG_IP_MULTIPLE_TABLES
185         res.r = NULL;
186 #endif
187
188         local_table = fib_get_table(net, RT_TABLE_LOCAL);
189         if (local_table) {
190                 ret = RTN_UNICAST;
191                 if (!local_table->tb_lookup(local_table, &fl, &res)) {
192                         if (!dev || dev == res.fi->fib_dev)
193                                 ret = res.type;
194                         fib_res_put(&res);
195                 }
196         }
197         return ret;
198 }
199
200 unsigned int inet_addr_type(struct net *net, __be32 addr)
201 {
202         return __inet_dev_addr_type(net, NULL, addr);
203 }
204
205 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
206                                 __be32 addr)
207 {
208        return __inet_dev_addr_type(net, dev, addr);
209 }
210
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
213      address.
214    - figure out what "logical" interface this packet arrived
215      and calculate "specific destination" address.
216    - check, that packet arrived from expected physical interface.
217  */
218
219 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
220                         struct net_device *dev, __be32 *spec_dst, u32 *itag)
221 {
222         struct in_device *in_dev;
223         struct flowi fl = { .nl_u = { .ip4_u =
224                                       { .daddr = src,
225                                         .saddr = dst,
226                                         .tos = tos } },
227                             .iif = oif };
228         struct fib_result res;
229         int no_addr, rpf;
230         int ret;
231
232         no_addr = rpf = 0;
233         rcu_read_lock();
234         in_dev = __in_dev_get_rcu(dev);
235         if (in_dev) {
236                 no_addr = in_dev->ifa_list == NULL;
237                 rpf = IN_DEV_RPFILTER(in_dev);
238         }
239         rcu_read_unlock();
240
241         if (in_dev == NULL)
242                 goto e_inval;
243
244         if (fib_lookup(&fl, &res))
245                 goto last_resort;
246         if (res.type != RTN_UNICAST)
247                 goto e_inval_res;
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)
252 #else
253         if (FIB_RES_DEV(res) == dev)
254 #endif
255         {
256                 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
257                 fib_res_put(&res);
258                 return ret;
259         }
260         fib_res_put(&res);
261         if (no_addr)
262                 goto last_resort;
263         if (rpf)
264                 goto e_inval;
265         fl.oif = dev->ifindex;
266
267         ret = 0;
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;
272                 }
273                 fib_res_put(&res);
274         }
275         return ret;
276
277 last_resort:
278         if (rpf)
279                 goto e_inval;
280         *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
281         *itag = 0;
282         return 0;
283
284 e_inval_res:
285         fib_res_put(&res);
286 e_inval:
287         return -EINVAL;
288 }
289
290 static inline __be32 sk_extract_addr(struct sockaddr *addr)
291 {
292         return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
293 }
294
295 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
296 {
297         struct nlattr *nla;
298
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;
303
304         return len + nla_total_size(4);
305 }
306
307 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
308                                  struct fib_config *cfg)
309 {
310         __be32 addr;
311         int plen;
312
313         memset(cfg, 0, sizeof(*cfg));
314         cfg->fc_nlinfo.nl_net = net;
315
316         if (rt->rt_dst.sa_family != AF_INET)
317                 return -EAFNOSUPPORT;
318
319         /*
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.
326          */
327         plen = 32;
328         addr = sk_extract_addr(&rt->rt_dst);
329         if (!(rt->rt_flags & RTF_HOST)) {
330                 __be32 mask = sk_extract_addr(&rt->rt_genmask);
331
332                 if (rt->rt_genmask.sa_family != AF_INET) {
333                         if (mask || rt->rt_genmask.sa_family)
334                                 return -EAFNOSUPPORT;
335                 }
336
337                 if (bad_mask(mask, addr))
338                         return -EINVAL;
339
340                 plen = inet_mask_len(mask);
341         }
342
343         cfg->fc_dst_len = plen;
344         cfg->fc_dst = addr;
345
346         if (cmd != SIOCDELRT) {
347                 cfg->fc_nlflags = NLM_F_CREATE;
348                 cfg->fc_protocol = RTPROT_BOOT;
349         }
350
351         if (rt->rt_metric)
352                 cfg->fc_priority = rt->rt_metric - 1;
353
354         if (rt->rt_flags & RTF_REJECT) {
355                 cfg->fc_scope = RT_SCOPE_HOST;
356                 cfg->fc_type = RTN_UNREACHABLE;
357                 return 0;
358         }
359
360         cfg->fc_scope = RT_SCOPE_NOWHERE;
361         cfg->fc_type = RTN_UNICAST;
362
363         if (rt->rt_dev) {
364                 char *colon;
365                 struct net_device *dev;
366                 char devname[IFNAMSIZ];
367
368                 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
369                         return -EFAULT;
370
371                 devname[IFNAMSIZ-1] = 0;
372                 colon = strchr(devname, ':');
373                 if (colon)
374                         *colon = 0;
375                 dev = __dev_get_by_name(net, devname);
376                 if (!dev)
377                         return -ENODEV;
378                 cfg->fc_oif = dev->ifindex;
379                 if (colon) {
380                         struct in_ifaddr *ifa;
381                         struct in_device *in_dev = __in_dev_get_rtnl(dev);
382                         if (!in_dev)
383                                 return -ENODEV;
384                         *colon = ':';
385                         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
386                                 if (strcmp(ifa->ifa_label, devname) == 0)
387                                         break;
388                         if (ifa == NULL)
389                                 return -ENODEV;
390                         cfg->fc_prefsrc = ifa->ifa_local;
391                 }
392         }
393
394         addr = sk_extract_addr(&rt->rt_gateway);
395         if (rt->rt_gateway.sa_family == AF_INET && addr) {
396                 cfg->fc_gw = addr;
397                 if (rt->rt_flags & RTF_GATEWAY &&
398                     inet_addr_type(net, addr) == RTN_UNICAST)
399                         cfg->fc_scope = RT_SCOPE_UNIVERSE;
400         }
401
402         if (cmd == SIOCDELRT)
403                 return 0;
404
405         if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
406                 return -EINVAL;
407
408         if (cfg->fc_scope == RT_SCOPE_NOWHERE)
409                 cfg->fc_scope = RT_SCOPE_LINK;
410
411         if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
412                 struct nlattr *mx;
413                 int len = 0;
414
415                 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
416                 if (mx == NULL)
417                         return -ENOMEM;
418
419                 if (rt->rt_flags & RTF_MTU)
420                         len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
421
422                 if (rt->rt_flags & RTF_WINDOW)
423                         len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
424
425                 if (rt->rt_flags & RTF_IRTT)
426                         len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
427
428                 cfg->fc_mx = mx;
429                 cfg->fc_mx_len = len;
430         }
431
432         return 0;
433 }
434
435 /*
436  *      Handle IP routing ioctl calls. These are used to manipulate the routing tables
437  */
438
439 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
440 {
441         struct fib_config cfg;
442         struct rtentry rt;
443         int err;
444
445         switch (cmd) {
446         case SIOCADDRT:         /* Add a route */
447         case SIOCDELRT:         /* Delete a route */
448                 if (!capable(CAP_NET_ADMIN))
449                         return -EPERM;
450
451                 if (copy_from_user(&rt, arg, sizeof(rt)))
452                         return -EFAULT;
453
454                 rtnl_lock();
455                 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
456                 if (err == 0) {
457                         struct fib_table *tb;
458
459                         if (cmd == SIOCDELRT) {
460                                 tb = fib_get_table(net, cfg.fc_table);
461                                 if (tb)
462                                         err = tb->tb_delete(tb, &cfg);
463                                 else
464                                         err = -ESRCH;
465                         } else {
466                                 tb = fib_new_table(net, cfg.fc_table);
467                                 if (tb)
468                                         err = tb->tb_insert(tb, &cfg);
469                                 else
470                                         err = -ENOBUFS;
471                         }
472
473                         /* allocated by rtentry_to_fib_config() */
474                         kfree(cfg.fc_mx);
475                 }
476                 rtnl_unlock();
477                 return err;
478         }
479         return -EINVAL;
480 }
481
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 },
494 };
495
496 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
497                             struct nlmsghdr *nlh, struct fib_config *cfg)
498 {
499         struct nlattr *attr;
500         int err, remaining;
501         struct rtmsg *rtm;
502
503         err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
504         if (err < 0)
505                 goto errout;
506
507         memset(cfg, 0, sizeof(*cfg));
508
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;
518
519         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
520         cfg->fc_nlinfo.nlh = nlh;
521         cfg->fc_nlinfo.nl_net = net;
522
523         if (cfg->fc_type > RTN_MAX) {
524                 err = -EINVAL;
525                 goto errout;
526         }
527
528         nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
529                 switch (nla_type(attr)) {
530                 case RTA_DST:
531                         cfg->fc_dst = nla_get_be32(attr);
532                         break;
533                 case RTA_OIF:
534                         cfg->fc_oif = nla_get_u32(attr);
535                         break;
536                 case RTA_GATEWAY:
537                         cfg->fc_gw = nla_get_be32(attr);
538                         break;
539                 case RTA_PRIORITY:
540                         cfg->fc_priority = nla_get_u32(attr);
541                         break;
542                 case RTA_PREFSRC:
543                         cfg->fc_prefsrc = nla_get_be32(attr);
544                         break;
545                 case RTA_METRICS:
546                         cfg->fc_mx = nla_data(attr);
547                         cfg->fc_mx_len = nla_len(attr);
548                         break;
549                 case RTA_MULTIPATH:
550                         cfg->fc_mp = nla_data(attr);
551                         cfg->fc_mp_len = nla_len(attr);
552                         break;
553                 case RTA_FLOW:
554                         cfg->fc_flow = nla_get_u32(attr);
555                         break;
556                 case RTA_TABLE:
557                         cfg->fc_table = nla_get_u32(attr);
558                         break;
559                 }
560         }
561
562         return 0;
563 errout:
564         return err;
565 }
566
567 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
568 {
569         struct net *net = skb->sk->sk_net;
570         struct fib_config cfg;
571         struct fib_table *tb;
572         int err;
573
574         err = rtm_to_fib_config(net, skb, nlh, &cfg);
575         if (err < 0)
576                 goto errout;
577
578         tb = fib_get_table(net, cfg.fc_table);
579         if (tb == NULL) {
580                 err = -ESRCH;
581                 goto errout;
582         }
583
584         err = tb->tb_delete(tb, &cfg);
585 errout:
586         return err;
587 }
588
589 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
590 {
591         struct net *net = skb->sk->sk_net;
592         struct fib_config cfg;
593         struct fib_table *tb;
594         int err;
595
596         err = rtm_to_fib_config(net, skb, nlh, &cfg);
597         if (err < 0)
598                 goto errout;
599
600         tb = fib_new_table(net, cfg.fc_table);
601         if (tb == NULL) {
602                 err = -ENOBUFS;
603                 goto errout;
604         }
605
606         err = tb->tb_insert(tb, &cfg);
607 errout:
608         return err;
609 }
610
611 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
612 {
613         struct net *net = skb->sk->sk_net;
614         unsigned int h, s_h;
615         unsigned int e = 0, s_e;
616         struct fib_table *tb;
617         struct hlist_node *node;
618         struct hlist_head *head;
619         int dumped = 0;
620
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);
624
625         s_h = cb->args[0];
626         s_e = cb->args[1];
627
628         for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
629                 e = 0;
630                 head = &net->ipv4.fib_table_hash[h];
631                 hlist_for_each_entry(tb, node, head, tb_hlist) {
632                         if (e < s_e)
633                                 goto next;
634                         if (dumped)
635                                 memset(&cb->args[2], 0, sizeof(cb->args) -
636                                                  2 * sizeof(cb->args[0]));
637                         if (tb->tb_dump(tb, skb, cb) < 0)
638                                 goto out;
639                         dumped = 1;
640 next:
641                         e++;
642                 }
643         }
644 out:
645         cb->args[1] = e;
646         cb->args[0] = h;
647
648         return skb->len;
649 }
650
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.
656  */
657
658 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
659 {
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,
664                 .fc_type = type,
665                 .fc_dst = dst,
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,
670                 .fc_nlinfo = {
671                         .nl_net = net,
672                 },
673         };
674
675         if (type == RTN_UNICAST)
676                 tb = fib_new_table(net, RT_TABLE_MAIN);
677         else
678                 tb = fib_new_table(net, RT_TABLE_LOCAL);
679
680         if (tb == NULL)
681                 return;
682
683         cfg.fc_table = tb->tb_id;
684
685         if (type != RTN_LOCAL)
686                 cfg.fc_scope = RT_SCOPE_LINK;
687         else
688                 cfg.fc_scope = RT_SCOPE_HOST;
689
690         if (cmd == RTM_NEWROUTE)
691                 tb->tb_insert(tb, &cfg);
692         else
693                 tb->tb_delete(tb, &cfg);
694 }
695
696 void fib_add_ifaddr(struct in_ifaddr *ifa)
697 {
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;
704
705         if (ifa->ifa_flags&IFA_F_SECONDARY) {
706                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
707                 if (prim == NULL) {
708                         printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
709                         return;
710                 }
711         }
712
713         fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
714
715         if (!(dev->flags&IFF_UP))
716                 return;
717
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);
721
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);
726
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);
731                 }
732         }
733 }
734
735 static void fib_del_ifaddr(struct in_ifaddr *ifa)
736 {
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;
743 #define LOCAL_OK        1
744 #define BRD_OK          2
745 #define BRD0_OK         4
746 #define BRD1_OK         8
747         unsigned ok = 0;
748
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);
752         else {
753                 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
754                 if (prim == NULL) {
755                         printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
756                         return;
757                 }
758         }
759
760         /* Deletion is more complicated than add.
761            We should take care of not to delete too much :-)
762
763            Scan address list to be sure that addresses are really gone.
764          */
765
766         for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
767                 if (ifa->ifa_local == ifa1->ifa_local)
768                         ok |= LOCAL_OK;
769                 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
770                         ok |= BRD_OK;
771                 if (brd == ifa1->ifa_broadcast)
772                         ok |= BRD1_OK;
773                 if (any == ifa1->ifa_broadcast)
774                         ok |= BRD0_OK;
775         }
776
777         if (!(ok&BRD_OK))
778                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
779         if (!(ok&BRD1_OK))
780                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
781         if (!(ok&BRD0_OK))
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);
785
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.
790
791                            First of all, we scan fib_info list searching
792                            for stray nexthop entries, then ignite fib_flush.
793                         */
794                         if (fib_sync_down(ifa->ifa_local, NULL, 0))
795                                 fib_flush(dev->nd_net);
796                 }
797         }
798 #undef LOCAL_OK
799 #undef BRD_OK
800 #undef BRD0_OK
801 #undef BRD1_OK
802 }
803
804 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
805 {
806
807         struct fib_result       res;
808         struct flowi            fl = { .mark = frn->fl_mark,
809                                        .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
810                                                             .tos = frn->fl_tos,
811                                                             .scope = frn->fl_scope } } };
812
813 #ifdef CONFIG_IP_MULTIPLE_TABLES
814         res.r = NULL;
815 #endif
816
817         frn->err = -ENOENT;
818         if (tb) {
819                 local_bh_disable();
820
821                 frn->tb_id = tb->tb_id;
822                 frn->err = tb->tb_lookup(tb, &fl, &res);
823
824                 if (!frn->err) {
825                         frn->prefixlen = res.prefixlen;
826                         frn->nh_sel = res.nh_sel;
827                         frn->type = res.type;
828                         frn->scope = res.scope;
829                         fib_res_put(&res);
830                 }
831                 local_bh_enable();
832         }
833 }
834
835 static void nl_fib_input(struct sk_buff *skb)
836 {
837         struct net *net;
838         struct fib_result_nl *frn;
839         struct nlmsghdr *nlh;
840         struct fib_table *tb;
841         u32 pid;
842
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)))
847                 return;
848
849         skb = skb_clone(skb, GFP_KERNEL);
850         if (skb == NULL)
851                 return;
852         nlh = nlmsg_hdr(skb);
853
854         frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
855         tb = fib_get_table(net, frn->tb_id_in);
856
857         nl_fib_lookup(frn, tb);
858
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);
863 }
864
865 static int nl_fib_lookup_init(struct net *net)
866 {
867         struct sock *sk;
868         sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
869                                    nl_fib_input, NULL, THIS_MODULE);
870         if (sk == NULL)
871                 return -EAFNOSUPPORT;
872         net->ipv4.fibnl = sk;
873         return 0;
874 }
875
876 static void nl_fib_lookup_exit(struct net *net)
877 {
878         netlink_kernel_release(net->ipv4.fibnl);
879         net->ipv4.fibnl = NULL;
880 }
881
882 static void fib_disable_ip(struct net_device *dev, int force)
883 {
884         if (fib_sync_down(0, dev, force))
885                 fib_flush(dev->nd_net);
886         rt_cache_flush(0);
887         arp_ifdown(dev);
888 }
889
890 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
891 {
892         struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
893
894         switch (event) {
895         case NETDEV_UP:
896                 fib_add_ifaddr(ifa);
897 #ifdef CONFIG_IP_ROUTE_MULTIPATH
898                 fib_sync_up(ifa->ifa_dev->dev);
899 #endif
900                 rt_cache_flush(-1);
901                 break;
902         case NETDEV_DOWN:
903                 fib_del_ifaddr(ifa);
904                 if (ifa->ifa_dev->ifa_list == NULL) {
905                         /* Last address was deleted from this interface.
906                            Disable IP.
907                          */
908                         fib_disable_ip(ifa->ifa_dev->dev, 1);
909                 } else {
910                         rt_cache_flush(-1);
911                 }
912                 break;
913         }
914         return NOTIFY_DONE;
915 }
916
917 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
918 {
919         struct net_device *dev = ptr;
920         struct in_device *in_dev = __in_dev_get_rtnl(dev);
921
922         if (event == NETDEV_UNREGISTER) {
923                 fib_disable_ip(dev, 2);
924                 return NOTIFY_DONE;
925         }
926
927         if (!in_dev)
928                 return NOTIFY_DONE;
929
930         switch (event) {
931         case NETDEV_UP:
932                 for_ifa(in_dev) {
933                         fib_add_ifaddr(ifa);
934                 } endfor_ifa(in_dev);
935 #ifdef CONFIG_IP_ROUTE_MULTIPATH
936                 fib_sync_up(dev);
937 #endif
938                 rt_cache_flush(-1);
939                 break;
940         case NETDEV_DOWN:
941                 fib_disable_ip(dev, 0);
942                 break;
943         case NETDEV_CHANGEMTU:
944         case NETDEV_CHANGE:
945                 rt_cache_flush(0);
946                 break;
947         }
948         return NOTIFY_DONE;
949 }
950
951 static struct notifier_block fib_inetaddr_notifier = {
952         .notifier_call =fib_inetaddr_event,
953 };
954
955 static struct notifier_block fib_netdev_notifier = {
956         .notifier_call =fib_netdev_event,
957 };
958
959 static int __net_init ip_fib_net_init(struct net *net)
960 {
961         unsigned int i;
962
963         net->ipv4.fib_table_hash = kzalloc(
964                         sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
965         if (net->ipv4.fib_table_hash == NULL)
966                 return -ENOMEM;
967
968         for (i = 0; i < FIB_TABLE_HASHSZ; i++)
969                 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
970
971         return fib4_rules_init(net);
972 }
973
974 static void __net_exit ip_fib_net_exit(struct net *net)
975 {
976         unsigned int i;
977
978 #ifdef CONFIG_IP_MULTIPLE_TABLES
979         fib4_rules_exit(net);
980 #endif
981
982         for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
983                 struct fib_table *tb;
984                 struct hlist_head *head;
985                 struct hlist_node *node, *tmp;
986
987                 head = &net->ipv4.fib_table_hash[i];
988                 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
989                         hlist_del(node);
990                         tb->tb_flush(tb);
991                         kfree(tb);
992                 }
993         }
994         kfree(net->ipv4.fib_table_hash);
995 }
996
997 static int __net_init fib_net_init(struct net *net)
998 {
999         int error;
1000
1001         error = ip_fib_net_init(net);
1002         if (error < 0)
1003                 goto out;
1004         error = nl_fib_lookup_init(net);
1005         if (error < 0)
1006                 goto out_nlfl;
1007         error = fib_proc_init(net);
1008         if (error < 0)
1009                 goto out_proc;
1010 out:
1011         return error;
1012
1013 out_proc:
1014         nl_fib_lookup_exit(net);
1015 out_nlfl:
1016         ip_fib_net_exit(net);
1017         goto out;
1018 }
1019
1020 static void __net_exit fib_net_exit(struct net *net)
1021 {
1022         fib_proc_exit(net);
1023         nl_fib_lookup_exit(net);
1024         ip_fib_net_exit(net);
1025 }
1026
1027 static struct pernet_operations fib_net_ops = {
1028         .init = fib_net_init,
1029         .exit = fib_net_exit,
1030 };
1031
1032 void __init ip_fib_init(void)
1033 {
1034         rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1035         rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1036         rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1037
1038         register_pernet_subsys(&fib_net_ops);
1039         register_netdevice_notifier(&fib_netdev_notifier);
1040         register_inetaddr_notifier(&fib_inetaddr_notifier);
1041
1042         fib_hash_init();
1043 }
1044
1045 EXPORT_SYMBOL(inet_addr_type);
1046 EXPORT_SYMBOL(inet_dev_addr_type);
1047 EXPORT_SYMBOL(ip_dev_find);