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