[TCP]: tcp_write_timeout.c cleanup
[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 #define FFprint(a...) printk(KERN_DEBUG a)
51
52 static struct sock *fibnl;
53
54 #ifndef CONFIG_IP_MULTIPLE_TABLES
55
56 struct fib_table *ip_fib_local_table;
57 struct fib_table *ip_fib_main_table;
58
59 #define FIB_TABLE_HASHSZ 1
60 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
61
62 static void __init fib4_rules_init(void)
63 {
64         ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
65         hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
66         ip_fib_main_table  = fib_hash_init(RT_TABLE_MAIN);
67         hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
68 }
69 #else
70
71 #define FIB_TABLE_HASHSZ 256
72 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
73
74 struct fib_table *fib_new_table(u32 id)
75 {
76         struct fib_table *tb;
77         unsigned int h;
78
79         if (id == 0)
80                 id = RT_TABLE_MAIN;
81         tb = fib_get_table(id);
82         if (tb)
83                 return tb;
84         tb = fib_hash_init(id);
85         if (!tb)
86                 return NULL;
87         h = id & (FIB_TABLE_HASHSZ - 1);
88         hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
89         return tb;
90 }
91
92 struct fib_table *fib_get_table(u32 id)
93 {
94         struct fib_table *tb;
95         struct hlist_node *node;
96         unsigned int h;
97
98         if (id == 0)
99                 id = RT_TABLE_MAIN;
100         h = id & (FIB_TABLE_HASHSZ - 1);
101         rcu_read_lock();
102         hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
103                 if (tb->tb_id == id) {
104                         rcu_read_unlock();
105                         return tb;
106                 }
107         }
108         rcu_read_unlock();
109         return NULL;
110 }
111 #endif /* CONFIG_IP_MULTIPLE_TABLES */
112
113 static void fib_flush(void)
114 {
115         int flushed = 0;
116         struct fib_table *tb;
117         struct hlist_node *node;
118         unsigned int h;
119
120         for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
121                 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
122                         flushed += tb->tb_flush(tb);
123         }
124
125         if (flushed)
126                 rt_cache_flush(-1);
127 }
128
129 /*
130  *      Find the first device with a given source address.
131  */
132
133 struct net_device * ip_dev_find(__be32 addr)
134 {
135         struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
136         struct fib_result res;
137         struct net_device *dev = NULL;
138         struct fib_table *local_table;
139
140 #ifdef CONFIG_IP_MULTIPLE_TABLES
141         res.r = NULL;
142 #endif
143
144         local_table = fib_get_table(RT_TABLE_LOCAL);
145         if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
146                 return NULL;
147         if (res.type != RTN_LOCAL)
148                 goto out;
149         dev = FIB_RES_DEV(res);
150
151         if (dev)
152                 dev_hold(dev);
153 out:
154         fib_res_put(&res);
155         return dev;
156 }
157
158 /*
159  * Find address type as if only "dev" was present in the system. If
160  * on_dev is NULL then all interfaces are taken into consideration.
161  */
162 static inline unsigned __inet_dev_addr_type(const struct net_device *dev,
163                                             __be32 addr)
164 {
165         struct flowi            fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
166         struct fib_result       res;
167         unsigned ret = RTN_BROADCAST;
168         struct fib_table *local_table;
169
170         if (ipv4_is_zeronet(addr) || ipv4_is_badclass(addr))
171                 return RTN_BROADCAST;
172         if (ipv4_is_multicast(addr))
173                 return RTN_MULTICAST;
174
175 #ifdef CONFIG_IP_MULTIPLE_TABLES
176         res.r = NULL;
177 #endif
178
179         local_table = fib_get_table(RT_TABLE_LOCAL);
180         if (local_table) {
181                 ret = RTN_UNICAST;
182                 if (!local_table->tb_lookup(local_table, &fl, &res)) {
183                         if (!dev || dev == res.fi->fib_dev)
184                                 ret = res.type;
185                         fib_res_put(&res);
186                 }
187         }
188         return ret;
189 }
190
191 unsigned int inet_addr_type(__be32 addr)
192 {
193         return __inet_dev_addr_type(NULL, addr);
194 }
195
196 unsigned int inet_dev_addr_type(const struct net_device *dev, __be32 addr)
197 {
198        return __inet_dev_addr_type(dev, addr);
199 }
200
201 /* Given (packet source, input interface) and optional (dst, oif, tos):
202    - (main) check, that source is valid i.e. not broadcast or our local
203      address.
204    - figure out what "logical" interface this packet arrived
205      and calculate "specific destination" address.
206    - check, that packet arrived from expected physical interface.
207  */
208
209 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
210                         struct net_device *dev, __be32 *spec_dst, u32 *itag)
211 {
212         struct in_device *in_dev;
213         struct flowi fl = { .nl_u = { .ip4_u =
214                                       { .daddr = src,
215                                         .saddr = dst,
216                                         .tos = tos } },
217                             .iif = oif };
218         struct fib_result res;
219         int no_addr, rpf;
220         int ret;
221
222         no_addr = rpf = 0;
223         rcu_read_lock();
224         in_dev = __in_dev_get_rcu(dev);
225         if (in_dev) {
226                 no_addr = in_dev->ifa_list == NULL;
227                 rpf = IN_DEV_RPFILTER(in_dev);
228         }
229         rcu_read_unlock();
230
231         if (in_dev == NULL)
232                 goto e_inval;
233
234         if (fib_lookup(&fl, &res))
235                 goto last_resort;
236         if (res.type != RTN_UNICAST)
237                 goto e_inval_res;
238         *spec_dst = FIB_RES_PREFSRC(res);
239         fib_combine_itag(itag, &res);
240 #ifdef CONFIG_IP_ROUTE_MULTIPATH
241         if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
242 #else
243         if (FIB_RES_DEV(res) == dev)
244 #endif
245         {
246                 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
247                 fib_res_put(&res);
248                 return ret;
249         }
250         fib_res_put(&res);
251         if (no_addr)
252                 goto last_resort;
253         if (rpf)
254                 goto e_inval;
255         fl.oif = dev->ifindex;
256
257         ret = 0;
258         if (fib_lookup(&fl, &res) == 0) {
259                 if (res.type == RTN_UNICAST) {
260                         *spec_dst = FIB_RES_PREFSRC(res);
261                         ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
262                 }
263                 fib_res_put(&res);
264         }
265         return ret;
266
267 last_resort:
268         if (rpf)
269                 goto e_inval;
270         *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
271         *itag = 0;
272         return 0;
273
274 e_inval_res:
275         fib_res_put(&res);
276 e_inval:
277         return -EINVAL;
278 }
279
280 static inline __be32 sk_extract_addr(struct sockaddr *addr)
281 {
282         return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
283 }
284
285 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
286 {
287         struct nlattr *nla;
288
289         nla = (struct nlattr *) ((char *) mx + len);
290         nla->nla_type = type;
291         nla->nla_len = nla_attr_size(4);
292         *(u32 *) nla_data(nla) = value;
293
294         return len + nla_total_size(4);
295 }
296
297 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
298                                  struct fib_config *cfg)
299 {
300         __be32 addr;
301         int plen;
302
303         memset(cfg, 0, sizeof(*cfg));
304
305         if (rt->rt_dst.sa_family != AF_INET)
306                 return -EAFNOSUPPORT;
307
308         /*
309          * Check mask for validity:
310          * a) it must be contiguous.
311          * b) destination must have all host bits clear.
312          * c) if application forgot to set correct family (AF_INET),
313          *    reject request unless it is absolutely clear i.e.
314          *    both family and mask are zero.
315          */
316         plen = 32;
317         addr = sk_extract_addr(&rt->rt_dst);
318         if (!(rt->rt_flags & RTF_HOST)) {
319                 __be32 mask = sk_extract_addr(&rt->rt_genmask);
320
321                 if (rt->rt_genmask.sa_family != AF_INET) {
322                         if (mask || rt->rt_genmask.sa_family)
323                                 return -EAFNOSUPPORT;
324                 }
325
326                 if (bad_mask(mask, addr))
327                         return -EINVAL;
328
329                 plen = inet_mask_len(mask);
330         }
331
332         cfg->fc_dst_len = plen;
333         cfg->fc_dst = addr;
334
335         if (cmd != SIOCDELRT) {
336                 cfg->fc_nlflags = NLM_F_CREATE;
337                 cfg->fc_protocol = RTPROT_BOOT;
338         }
339
340         if (rt->rt_metric)
341                 cfg->fc_priority = rt->rt_metric - 1;
342
343         if (rt->rt_flags & RTF_REJECT) {
344                 cfg->fc_scope = RT_SCOPE_HOST;
345                 cfg->fc_type = RTN_UNREACHABLE;
346                 return 0;
347         }
348
349         cfg->fc_scope = RT_SCOPE_NOWHERE;
350         cfg->fc_type = RTN_UNICAST;
351
352         if (rt->rt_dev) {
353                 char *colon;
354                 struct net_device *dev;
355                 char devname[IFNAMSIZ];
356
357                 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
358                         return -EFAULT;
359
360                 devname[IFNAMSIZ-1] = 0;
361                 colon = strchr(devname, ':');
362                 if (colon)
363                         *colon = 0;
364                 dev = __dev_get_by_name(&init_net, devname);
365                 if (!dev)
366                         return -ENODEV;
367                 cfg->fc_oif = dev->ifindex;
368                 if (colon) {
369                         struct in_ifaddr *ifa;
370                         struct in_device *in_dev = __in_dev_get_rtnl(dev);
371                         if (!in_dev)
372                                 return -ENODEV;
373                         *colon = ':';
374                         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
375                                 if (strcmp(ifa->ifa_label, devname) == 0)
376                                         break;
377                         if (ifa == NULL)
378                                 return -ENODEV;
379                         cfg->fc_prefsrc = ifa->ifa_local;
380                 }
381         }
382
383         addr = sk_extract_addr(&rt->rt_gateway);
384         if (rt->rt_gateway.sa_family == AF_INET && addr) {
385                 cfg->fc_gw = addr;
386                 if (rt->rt_flags & RTF_GATEWAY &&
387                     inet_addr_type(addr) == RTN_UNICAST)
388                         cfg->fc_scope = RT_SCOPE_UNIVERSE;
389         }
390
391         if (cmd == SIOCDELRT)
392                 return 0;
393
394         if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
395                 return -EINVAL;
396
397         if (cfg->fc_scope == RT_SCOPE_NOWHERE)
398                 cfg->fc_scope = RT_SCOPE_LINK;
399
400         if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
401                 struct nlattr *mx;
402                 int len = 0;
403
404                 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
405                 if (mx == NULL)
406                         return -ENOMEM;
407
408                 if (rt->rt_flags & RTF_MTU)
409                         len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
410
411                 if (rt->rt_flags & RTF_WINDOW)
412                         len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
413
414                 if (rt->rt_flags & RTF_IRTT)
415                         len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
416
417                 cfg->fc_mx = mx;
418                 cfg->fc_mx_len = len;
419         }
420
421         return 0;
422 }
423
424 /*
425  *      Handle IP routing ioctl calls. These are used to manipulate the routing tables
426  */
427
428 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
429 {
430         struct fib_config cfg;
431         struct rtentry rt;
432         int err;
433
434         switch (cmd) {
435         case SIOCADDRT:         /* Add a route */
436         case SIOCDELRT:         /* Delete a route */
437                 if (!capable(CAP_NET_ADMIN))
438                         return -EPERM;
439
440                 if (copy_from_user(&rt, arg, sizeof(rt)))
441                         return -EFAULT;
442
443                 rtnl_lock();
444                 err = rtentry_to_fib_config(cmd, &rt, &cfg);
445                 if (err == 0) {
446                         struct fib_table *tb;
447
448                         if (cmd == SIOCDELRT) {
449                                 tb = fib_get_table(cfg.fc_table);
450                                 if (tb)
451                                         err = tb->tb_delete(tb, &cfg);
452                                 else
453                                         err = -ESRCH;
454                         } else {
455                                 tb = fib_new_table(cfg.fc_table);
456                                 if (tb)
457                                         err = tb->tb_insert(tb, &cfg);
458                                 else
459                                         err = -ENOBUFS;
460                         }
461
462                         /* allocated by rtentry_to_fib_config() */
463                         kfree(cfg.fc_mx);
464                 }
465                 rtnl_unlock();
466                 return err;
467         }
468         return -EINVAL;
469 }
470
471 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
472         [RTA_DST]               = { .type = NLA_U32 },
473         [RTA_SRC]               = { .type = NLA_U32 },
474         [RTA_IIF]               = { .type = NLA_U32 },
475         [RTA_OIF]               = { .type = NLA_U32 },
476         [RTA_GATEWAY]           = { .type = NLA_U32 },
477         [RTA_PRIORITY]          = { .type = NLA_U32 },
478         [RTA_PREFSRC]           = { .type = NLA_U32 },
479         [RTA_METRICS]           = { .type = NLA_NESTED },
480         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
481         [RTA_PROTOINFO]         = { .type = NLA_U32 },
482         [RTA_FLOW]              = { .type = NLA_U32 },
483 };
484
485 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
486                              struct fib_config *cfg)
487 {
488         struct nlattr *attr;
489         int err, remaining;
490         struct rtmsg *rtm;
491
492         err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
493         if (err < 0)
494                 goto errout;
495
496         memset(cfg, 0, sizeof(*cfg));
497
498         rtm = nlmsg_data(nlh);
499         cfg->fc_dst_len = rtm->rtm_dst_len;
500         cfg->fc_tos = rtm->rtm_tos;
501         cfg->fc_table = rtm->rtm_table;
502         cfg->fc_protocol = rtm->rtm_protocol;
503         cfg->fc_scope = rtm->rtm_scope;
504         cfg->fc_type = rtm->rtm_type;
505         cfg->fc_flags = rtm->rtm_flags;
506         cfg->fc_nlflags = nlh->nlmsg_flags;
507
508         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
509         cfg->fc_nlinfo.nlh = nlh;
510
511         if (cfg->fc_type > RTN_MAX) {
512                 err = -EINVAL;
513                 goto errout;
514         }
515
516         nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
517                 switch (nla_type(attr)) {
518                 case RTA_DST:
519                         cfg->fc_dst = nla_get_be32(attr);
520                         break;
521                 case RTA_OIF:
522                         cfg->fc_oif = nla_get_u32(attr);
523                         break;
524                 case RTA_GATEWAY:
525                         cfg->fc_gw = nla_get_be32(attr);
526                         break;
527                 case RTA_PRIORITY:
528                         cfg->fc_priority = nla_get_u32(attr);
529                         break;
530                 case RTA_PREFSRC:
531                         cfg->fc_prefsrc = nla_get_be32(attr);
532                         break;
533                 case RTA_METRICS:
534                         cfg->fc_mx = nla_data(attr);
535                         cfg->fc_mx_len = nla_len(attr);
536                         break;
537                 case RTA_MULTIPATH:
538                         cfg->fc_mp = nla_data(attr);
539                         cfg->fc_mp_len = nla_len(attr);
540                         break;
541                 case RTA_FLOW:
542                         cfg->fc_flow = nla_get_u32(attr);
543                         break;
544                 case RTA_TABLE:
545                         cfg->fc_table = nla_get_u32(attr);
546                         break;
547                 }
548         }
549
550         return 0;
551 errout:
552         return err;
553 }
554
555 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
556 {
557         struct net *net = skb->sk->sk_net;
558         struct fib_config cfg;
559         struct fib_table *tb;
560         int err;
561
562         if (net != &init_net)
563                 return -EINVAL;
564
565         err = rtm_to_fib_config(skb, nlh, &cfg);
566         if (err < 0)
567                 goto errout;
568
569         tb = fib_get_table(cfg.fc_table);
570         if (tb == NULL) {
571                 err = -ESRCH;
572                 goto errout;
573         }
574
575         err = tb->tb_delete(tb, &cfg);
576 errout:
577         return err;
578 }
579
580 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
581 {
582         struct net *net = skb->sk->sk_net;
583         struct fib_config cfg;
584         struct fib_table *tb;
585         int err;
586
587         if (net != &init_net)
588                 return -EINVAL;
589
590         err = rtm_to_fib_config(skb, nlh, &cfg);
591         if (err < 0)
592                 goto errout;
593
594         tb = fib_new_table(cfg.fc_table);
595         if (tb == NULL) {
596                 err = -ENOBUFS;
597                 goto errout;
598         }
599
600         err = tb->tb_insert(tb, &cfg);
601 errout:
602         return err;
603 }
604
605 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
606 {
607         struct net *net = skb->sk->sk_net;
608         unsigned int h, s_h;
609         unsigned int e = 0, s_e;
610         struct fib_table *tb;
611         struct hlist_node *node;
612         int dumped = 0;
613
614         if (net != &init_net)
615                 return 0;
616
617         if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
618             ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
619                 return ip_rt_dump(skb, cb);
620
621         s_h = cb->args[0];
622         s_e = cb->args[1];
623
624         for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
625                 e = 0;
626                 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
627                         if (e < s_e)
628                                 goto next;
629                         if (dumped)
630                                 memset(&cb->args[2], 0, sizeof(cb->args) -
631                                                  2 * sizeof(cb->args[0]));
632                         if (tb->tb_dump(tb, skb, cb) < 0)
633                                 goto out;
634                         dumped = 1;
635 next:
636                         e++;
637                 }
638         }
639 out:
640         cb->args[1] = e;
641         cb->args[0] = h;
642
643         return skb->len;
644 }
645
646 /* Prepare and feed intra-kernel routing request.
647    Really, it should be netlink message, but :-( netlink
648    can be not configured, so that we feed it directly
649    to fib engine. It is legal, because all events occur
650    only when netlink is already locked.
651  */
652
653 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
654 {
655         struct fib_table *tb;
656         struct fib_config cfg = {
657                 .fc_protocol = RTPROT_KERNEL,
658                 .fc_type = type,
659                 .fc_dst = dst,
660                 .fc_dst_len = dst_len,
661                 .fc_prefsrc = ifa->ifa_local,
662                 .fc_oif = ifa->ifa_dev->dev->ifindex,
663                 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
664         };
665
666         if (type == RTN_UNICAST)
667                 tb = fib_new_table(RT_TABLE_MAIN);
668         else
669                 tb = fib_new_table(RT_TABLE_LOCAL);
670
671         if (tb == NULL)
672                 return;
673
674         cfg.fc_table = tb->tb_id;
675
676         if (type != RTN_LOCAL)
677                 cfg.fc_scope = RT_SCOPE_LINK;
678         else
679                 cfg.fc_scope = RT_SCOPE_HOST;
680
681         if (cmd == RTM_NEWROUTE)
682                 tb->tb_insert(tb, &cfg);
683         else
684                 tb->tb_delete(tb, &cfg);
685 }
686
687 void fib_add_ifaddr(struct in_ifaddr *ifa)
688 {
689         struct in_device *in_dev = ifa->ifa_dev;
690         struct net_device *dev = in_dev->dev;
691         struct in_ifaddr *prim = ifa;
692         __be32 mask = ifa->ifa_mask;
693         __be32 addr = ifa->ifa_local;
694         __be32 prefix = ifa->ifa_address&mask;
695
696         if (ifa->ifa_flags&IFA_F_SECONDARY) {
697                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
698                 if (prim == NULL) {
699                         printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
700                         return;
701                 }
702         }
703
704         fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
705
706         if (!(dev->flags&IFF_UP))
707                 return;
708
709         /* Add broadcast address, if it is explicitly assigned. */
710         if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
711                 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
712
713         if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
714             (prefix != addr || ifa->ifa_prefixlen < 32)) {
715                 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
716                           RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
717
718                 /* Add network specific broadcasts, when it takes a sense */
719                 if (ifa->ifa_prefixlen < 31) {
720                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
721                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
722                 }
723         }
724 }
725
726 static void fib_del_ifaddr(struct in_ifaddr *ifa)
727 {
728         struct in_device *in_dev = ifa->ifa_dev;
729         struct net_device *dev = in_dev->dev;
730         struct in_ifaddr *ifa1;
731         struct in_ifaddr *prim = ifa;
732         __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
733         __be32 any = ifa->ifa_address&ifa->ifa_mask;
734 #define LOCAL_OK        1
735 #define BRD_OK          2
736 #define BRD0_OK         4
737 #define BRD1_OK         8
738         unsigned ok = 0;
739
740         if (!(ifa->ifa_flags&IFA_F_SECONDARY))
741                 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
742                           RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
743         else {
744                 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
745                 if (prim == NULL) {
746                         printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
747                         return;
748                 }
749         }
750
751         /* Deletion is more complicated than add.
752            We should take care of not to delete too much :-)
753
754            Scan address list to be sure that addresses are really gone.
755          */
756
757         for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
758                 if (ifa->ifa_local == ifa1->ifa_local)
759                         ok |= LOCAL_OK;
760                 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
761                         ok |= BRD_OK;
762                 if (brd == ifa1->ifa_broadcast)
763                         ok |= BRD1_OK;
764                 if (any == ifa1->ifa_broadcast)
765                         ok |= BRD0_OK;
766         }
767
768         if (!(ok&BRD_OK))
769                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
770         if (!(ok&BRD1_OK))
771                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
772         if (!(ok&BRD0_OK))
773                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
774         if (!(ok&LOCAL_OK)) {
775                 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
776
777                 /* Check, that this local address finally disappeared. */
778                 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
779                         /* And the last, but not the least thing.
780                            We must flush stray FIB entries.
781
782                            First of all, we scan fib_info list searching
783                            for stray nexthop entries, then ignite fib_flush.
784                         */
785                         if (fib_sync_down(ifa->ifa_local, NULL, 0))
786                                 fib_flush();
787                 }
788         }
789 #undef LOCAL_OK
790 #undef BRD_OK
791 #undef BRD0_OK
792 #undef BRD1_OK
793 }
794
795 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
796 {
797
798         struct fib_result       res;
799         struct flowi            fl = { .mark = frn->fl_mark,
800                                        .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
801                                                             .tos = frn->fl_tos,
802                                                             .scope = frn->fl_scope } } };
803
804 #ifdef CONFIG_IP_MULTIPLE_TABLES
805         res.r = NULL;
806 #endif
807
808         frn->err = -ENOENT;
809         if (tb) {
810                 local_bh_disable();
811
812                 frn->tb_id = tb->tb_id;
813                 frn->err = tb->tb_lookup(tb, &fl, &res);
814
815                 if (!frn->err) {
816                         frn->prefixlen = res.prefixlen;
817                         frn->nh_sel = res.nh_sel;
818                         frn->type = res.type;
819                         frn->scope = res.scope;
820                         fib_res_put(&res);
821                 }
822                 local_bh_enable();
823         }
824 }
825
826 static void nl_fib_input(struct sk_buff *skb)
827 {
828         struct fib_result_nl *frn;
829         struct nlmsghdr *nlh;
830         struct fib_table *tb;
831         u32 pid;
832
833         nlh = nlmsg_hdr(skb);
834         if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
835             nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
836                 return;
837
838         skb = skb_clone(skb, GFP_KERNEL);
839         if (skb == NULL)
840                 return;
841         nlh = nlmsg_hdr(skb);
842
843         frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
844         tb = fib_get_table(frn->tb_id_in);
845
846         nl_fib_lookup(frn, tb);
847
848         pid = NETLINK_CB(skb).pid;       /* pid of sending process */
849         NETLINK_CB(skb).pid = 0;         /* from kernel */
850         NETLINK_CB(skb).dst_group = 0;  /* unicast */
851         netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
852 }
853
854 static void nl_fib_lookup_init(void)
855 {
856         fibnl = netlink_kernel_create(&init_net, NETLINK_FIB_LOOKUP, 0,
857                                       nl_fib_input, NULL, THIS_MODULE);
858 }
859
860 static void fib_disable_ip(struct net_device *dev, int force)
861 {
862         if (fib_sync_down(0, dev, force))
863                 fib_flush();
864         rt_cache_flush(0);
865         arp_ifdown(dev);
866 }
867
868 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
869 {
870         struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
871
872         switch (event) {
873         case NETDEV_UP:
874                 fib_add_ifaddr(ifa);
875 #ifdef CONFIG_IP_ROUTE_MULTIPATH
876                 fib_sync_up(ifa->ifa_dev->dev);
877 #endif
878                 rt_cache_flush(-1);
879                 break;
880         case NETDEV_DOWN:
881                 fib_del_ifaddr(ifa);
882                 if (ifa->ifa_dev->ifa_list == NULL) {
883                         /* Last address was deleted from this interface.
884                            Disable IP.
885                          */
886                         fib_disable_ip(ifa->ifa_dev->dev, 1);
887                 } else {
888                         rt_cache_flush(-1);
889                 }
890                 break;
891         }
892         return NOTIFY_DONE;
893 }
894
895 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
896 {
897         struct net_device *dev = ptr;
898         struct in_device *in_dev = __in_dev_get_rtnl(dev);
899
900         if (dev->nd_net != &init_net)
901                 return NOTIFY_DONE;
902
903         if (event == NETDEV_UNREGISTER) {
904                 fib_disable_ip(dev, 2);
905                 return NOTIFY_DONE;
906         }
907
908         if (!in_dev)
909                 return NOTIFY_DONE;
910
911         switch (event) {
912         case NETDEV_UP:
913                 for_ifa(in_dev) {
914                         fib_add_ifaddr(ifa);
915                 } endfor_ifa(in_dev);
916 #ifdef CONFIG_IP_ROUTE_MULTIPATH
917                 fib_sync_up(dev);
918 #endif
919                 rt_cache_flush(-1);
920                 break;
921         case NETDEV_DOWN:
922                 fib_disable_ip(dev, 0);
923                 break;
924         case NETDEV_CHANGEMTU:
925         case NETDEV_CHANGE:
926                 rt_cache_flush(0);
927                 break;
928         }
929         return NOTIFY_DONE;
930 }
931
932 static struct notifier_block fib_inetaddr_notifier = {
933         .notifier_call =fib_inetaddr_event,
934 };
935
936 static struct notifier_block fib_netdev_notifier = {
937         .notifier_call =fib_netdev_event,
938 };
939
940 void __init ip_fib_init(void)
941 {
942         unsigned int i;
943
944         for (i = 0; i < FIB_TABLE_HASHSZ; i++)
945                 INIT_HLIST_HEAD(&fib_table_hash[i]);
946
947         fib4_rules_init();
948
949         register_netdevice_notifier(&fib_netdev_notifier);
950         register_inetaddr_notifier(&fib_inetaddr_notifier);
951         nl_fib_lookup_init();
952
953         rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
954         rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
955         rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
956 }
957
958 EXPORT_SYMBOL(inet_addr_type);
959 EXPORT_SYMBOL(inet_dev_addr_type);
960 EXPORT_SYMBOL(ip_dev_find);