source: src/linux/universal/linux-3.18/net/ipv4/fib_frontend.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 2 months ago

update

File size: 28.6 KB
Line 
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 * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 *
10 *              This program is free software; you can redistribute it and/or
11 *              modify it under the terms of the GNU General Public License
12 *              as published by the Free Software Foundation; either version
13 *              2 of the License, or (at your option) any later version.
14 */
15
16#include <linux/module.h>
17#include <asm/uaccess.h>
18#include <linux/bitops.h>
19#include <linux/capability.h>
20#include <linux/types.h>
21#include <linux/kernel.h>
22#include <linux/mm.h>
23#include <linux/string.h>
24#include <linux/socket.h>
25#include <linux/sockios.h>
26#include <linux/errno.h>
27#include <linux/in.h>
28#include <linux/inet.h>
29#include <linux/inetdevice.h>
30#include <linux/netdevice.h>
31#include <linux/if_addr.h>
32#include <linux/if_arp.h>
33#include <linux/skbuff.h>
34#include <linux/cache.h>
35#include <linux/init.h>
36#include <linux/list.h>
37#include <linux/slab.h>
38
39#include <net/ip.h>
40#include <net/protocol.h>
41#include <net/route.h>
42#include <net/tcp.h>
43#include <net/sock.h>
44#include <net/arp.h>
45#include <net/ip_fib.h>
46#include <net/rtnetlink.h>
47#include <net/xfrm.h>
48
49#ifndef CONFIG_IP_MULTIPLE_TABLES
50
51static int __net_init fib4_rules_init(struct net *net)
52{
53        struct fib_table *local_table, *main_table;
54
55        main_table  = fib_trie_table(RT_TABLE_MAIN, NULL);
56        if (!main_table)
57                return -ENOMEM;
58
59        local_table = fib_trie_table(RT_TABLE_LOCAL, main_table);
60        if (!local_table)
61                goto fail;
62
63        hlist_add_head_rcu(&local_table->tb_hlist,
64                                &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
65        hlist_add_head_rcu(&main_table->tb_hlist,
66                                &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
67        return 0;
68
69fail:
70        fib_free_table(main_table);
71        return -ENOMEM;
72}
73#else
74
75struct fib_table *fib_new_table(struct net *net, u32 id)
76{
77        struct fib_table *tb, *alias = NULL;
78        unsigned int h;
79
80        if (id == 0)
81                id = RT_TABLE_MAIN;
82        tb = fib_get_table(net, id);
83        if (tb)
84                return tb;
85
86        if (id == RT_TABLE_LOCAL)
87                alias = fib_new_table(net, RT_TABLE_MAIN);
88
89        tb = fib_trie_table(id, alias);
90        if (!tb)
91                return NULL;
92
93        switch (id) {
94        case RT_TABLE_LOCAL:
95                rcu_assign_pointer(net->ipv4.fib_local, tb);
96                break;
97        case RT_TABLE_MAIN:
98                rcu_assign_pointer(net->ipv4.fib_main, tb);
99                break;
100        case RT_TABLE_DEFAULT:
101                rcu_assign_pointer(net->ipv4.fib_default, tb);
102                break;
103        default:
104                break;
105        }
106
107        h = id & (FIB_TABLE_HASHSZ - 1);
108        hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
109        return tb;
110}
111
112/* caller must hold either rtnl or rcu read lock */
113struct fib_table *fib_get_table(struct net *net, u32 id)
114{
115        struct fib_table *tb;
116        struct hlist_head *head;
117        unsigned int h;
118
119        if (id == 0)
120                id = RT_TABLE_MAIN;
121        h = id & (FIB_TABLE_HASHSZ - 1);
122
123        head = &net->ipv4.fib_table_hash[h];
124        hlist_for_each_entry_rcu(tb, head, tb_hlist) {
125                if (tb->tb_id == id)
126                        return tb;
127        }
128        return NULL;
129}
130#endif /* CONFIG_IP_MULTIPLE_TABLES */
131
132static void fib_replace_table(struct net *net, struct fib_table *old,
133                              struct fib_table *new)
134{
135#ifdef CONFIG_IP_MULTIPLE_TABLES
136        switch (new->tb_id) {
137        case RT_TABLE_LOCAL:
138                rcu_assign_pointer(net->ipv4.fib_local, new);
139                break;
140        case RT_TABLE_MAIN:
141                rcu_assign_pointer(net->ipv4.fib_main, new);
142                break;
143        case RT_TABLE_DEFAULT:
144                rcu_assign_pointer(net->ipv4.fib_default, new);
145                break;
146        default:
147                break;
148        }
149
150#endif
151        /* replace the old table in the hlist */
152        hlist_replace_rcu(&old->tb_hlist, &new->tb_hlist);
153}
154
155int fib_unmerge(struct net *net)
156{
157        struct fib_table *old, *new;
158
159        /* attempt to fetch local table if it has been allocated */
160        old = fib_get_table(net, RT_TABLE_LOCAL);
161        if (!old)
162                return 0;
163
164        new = fib_trie_unmerge(old);
165
166        if (!new)
167                return -ENOMEM;
168
169        /* replace merged table with clean table */
170        if (new != old) {
171                fib_replace_table(net, old, new);
172                fib_free_table(old);
173        }
174
175        return 0;
176}
177
178static void fib_flush(struct net *net)
179{
180        int flushed = 0;
181        unsigned int h;
182
183        for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
184                struct hlist_head *head = &net->ipv4.fib_table_hash[h];
185                struct hlist_node *tmp;
186                struct fib_table *tb;
187
188                hlist_for_each_entry_safe(tb, tmp, head, tb_hlist)
189                        flushed += fib_table_flush(tb);
190        }
191
192        if (flushed)
193                rt_cache_flush(net);
194}
195
196/*
197 * Find address type as if only "dev" was present in the system. If
198 * on_dev is NULL then all interfaces are taken into consideration.
199 */
200static inline unsigned int __inet_dev_addr_type(struct net *net,
201                                                const struct net_device *dev,
202                                                __be32 addr)
203{
204        struct flowi4           fl4 = { .daddr = addr };
205        struct fib_result       res;
206        unsigned int ret = RTN_BROADCAST;
207        struct fib_table *local_table;
208
209        if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
210                return RTN_BROADCAST;
211        if (ipv4_is_multicast(addr))
212                return RTN_MULTICAST;
213
214        rcu_read_lock();
215
216        local_table = fib_get_table(net, RT_TABLE_LOCAL);
217        if (local_table) {
218                ret = RTN_UNICAST;
219                if (!fib_table_lookup(local_table, &fl4, &res, FIB_LOOKUP_NOREF)) {
220                        if (!dev || dev == res.fi->fib_dev)
221                                ret = res.type;
222                }
223        }
224
225        rcu_read_unlock();
226        return ret;
227}
228
229unsigned int inet_addr_type(struct net *net, __be32 addr)
230{
231        return __inet_dev_addr_type(net, NULL, addr);
232}
233EXPORT_SYMBOL(inet_addr_type);
234
235unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
236                                __be32 addr)
237{
238        return __inet_dev_addr_type(net, dev, addr);
239}
240EXPORT_SYMBOL(inet_dev_addr_type);
241
242__be32 fib_compute_spec_dst(struct sk_buff *skb)
243{
244        struct net_device *dev = skb->dev;
245        struct in_device *in_dev;
246        struct fib_result res;
247        struct rtable *rt;
248        struct flowi4 fl4;
249        struct net *net;
250        int scope;
251
252        rt = skb_rtable(skb);
253        if ((rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST | RTCF_LOCAL)) ==
254            RTCF_LOCAL)
255                return ip_hdr(skb)->daddr;
256
257        in_dev = __in_dev_get_rcu(dev);
258        BUG_ON(!in_dev);
259
260        net = dev_net(dev);
261
262        scope = RT_SCOPE_UNIVERSE;
263        if (!ipv4_is_zeronet(ip_hdr(skb)->saddr)) {
264                fl4.flowi4_oif = 0;
265                fl4.flowi4_iif = LOOPBACK_IFINDEX;
266                fl4.daddr = ip_hdr(skb)->saddr;
267                fl4.saddr = 0;
268                fl4.flowi4_tos = RT_TOS(ip_hdr(skb)->tos);
269                fl4.flowi4_scope = scope;
270                fl4.flowi4_mark = IN_DEV_SRC_VMARK(in_dev) ? skb->mark : 0;
271                if (!fib_lookup(net, &fl4, &res))
272                        return FIB_RES_PREFSRC(net, res);
273        } else {
274                scope = RT_SCOPE_LINK;
275        }
276
277        return inet_select_addr(dev, ip_hdr(skb)->saddr, scope);
278}
279
280/* Given (packet source, input interface) and optional (dst, oif, tos):
281 * - (main) check, that source is valid i.e. not broadcast or our local
282 *   address.
283 * - figure out what "logical" interface this packet arrived
284 *   and calculate "specific destination" address.
285 * - check, that packet arrived from expected physical interface.
286 * called with rcu_read_lock()
287 */
288static int __fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
289                                 u8 tos, int oif, struct net_device *dev,
290                                 int rpf, struct in_device *idev, u32 *itag)
291{
292        int ret, no_addr;
293        struct fib_result res;
294        struct flowi4 fl4;
295        struct net *net;
296        bool dev_match;
297
298        fl4.flowi4_oif = 0;
299        fl4.flowi4_iif = oif ? : LOOPBACK_IFINDEX;
300        fl4.daddr = src;
301        fl4.saddr = dst;
302        fl4.flowi4_tos = tos;
303        fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
304
305        no_addr = idev->ifa_list == NULL;
306
307        fl4.flowi4_mark = IN_DEV_SRC_VMARK(idev) ? skb->mark : 0;
308
309        net = dev_net(dev);
310        if (fib_lookup(net, &fl4, &res))
311                goto last_resort;
312        if (res.type != RTN_UNICAST &&
313            (res.type != RTN_LOCAL || !IN_DEV_ACCEPT_LOCAL(idev)))
314                goto e_inval;
315        if (!rpf && !fib_num_tclassid_users(dev_net(dev)) &&
316            (dev->ifindex != oif || !IN_DEV_TX_REDIRECTS(idev)))
317                goto last_resort;
318        fib_combine_itag(itag, &res);
319        dev_match = false;
320
321#ifdef CONFIG_IP_ROUTE_MULTIPATH
322        for (ret = 0; ret < res.fi->fib_nhs; ret++) {
323                struct fib_nh *nh = &res.fi->fib_nh[ret];
324
325                if (nh->nh_dev == dev) {
326                        dev_match = true;
327                        break;
328                }
329        }
330#else
331        if (FIB_RES_DEV(res) == dev)
332                dev_match = true;
333#endif
334        if (dev_match) {
335                ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
336                return ret;
337        }
338        if (no_addr)
339                goto last_resort;
340        if (rpf == 1)
341                goto e_rpf;
342        fl4.flowi4_oif = dev->ifindex;
343
344        ret = 0;
345        if (fib_lookup(net, &fl4, &res) == 0) {
346                if (res.type == RTN_UNICAST)
347                        ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
348        }
349        return ret;
350
351last_resort:
352        if (rpf)
353                goto e_rpf;
354        *itag = 0;
355        return 0;
356
357e_inval:
358        return -EINVAL;
359e_rpf:
360        return -EXDEV;
361}
362
363/* Ignore rp_filter for packets protected by IPsec. */
364int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
365                        u8 tos, int oif, struct net_device *dev,
366                        struct in_device *idev, u32 *itag)
367{
368        int r = secpath_exists(skb) ? 0 : IN_DEV_RPFILTER(idev);
369
370        if (!r && !fib_num_tclassid_users(dev_net(dev)) &&
371            IN_DEV_ACCEPT_LOCAL(idev) &&
372            (dev->ifindex != oif || !IN_DEV_TX_REDIRECTS(idev))) {
373                *itag = 0;
374                return 0;
375        }
376        return __fib_validate_source(skb, src, dst, tos, oif, dev, r, idev, itag);
377}
378
379static inline __be32 sk_extract_addr(struct sockaddr *addr)
380{
381        return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
382}
383
384static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
385{
386        struct nlattr *nla;
387
388        nla = (struct nlattr *) ((char *) mx + len);
389        nla->nla_type = type;
390        nla->nla_len = nla_attr_size(4);
391        *(u32 *) nla_data(nla) = value;
392
393        return len + nla_total_size(4);
394}
395
396static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
397                                 struct fib_config *cfg)
398{
399        __be32 addr;
400        int plen;
401
402        memset(cfg, 0, sizeof(*cfg));
403        cfg->fc_nlinfo.nl_net = net;
404
405        if (rt->rt_dst.sa_family != AF_INET)
406                return -EAFNOSUPPORT;
407
408        /*
409         * Check mask for validity:
410         * a) it must be contiguous.
411         * b) destination must have all host bits clear.
412         * c) if application forgot to set correct family (AF_INET),
413         *    reject request unless it is absolutely clear i.e.
414         *    both family and mask are zero.
415         */
416        plen = 32;
417        addr = sk_extract_addr(&rt->rt_dst);
418        if (!(rt->rt_flags & RTF_HOST)) {
419                __be32 mask = sk_extract_addr(&rt->rt_genmask);
420
421                if (rt->rt_genmask.sa_family != AF_INET) {
422                        if (mask || rt->rt_genmask.sa_family)
423                                return -EAFNOSUPPORT;
424                }
425
426                if (bad_mask(mask, addr))
427                        return -EINVAL;
428
429                plen = inet_mask_len(mask);
430        }
431
432        cfg->fc_dst_len = plen;
433        cfg->fc_dst = addr;
434
435        if (cmd != SIOCDELRT) {
436                cfg->fc_nlflags = NLM_F_CREATE;
437                cfg->fc_protocol = RTPROT_BOOT;
438        }
439
440        if (rt->rt_metric)
441                cfg->fc_priority = rt->rt_metric - 1;
442
443        if (rt->rt_flags & RTF_REJECT) {
444                cfg->fc_scope = RT_SCOPE_HOST;
445                cfg->fc_type = RTN_UNREACHABLE;
446                return 0;
447        }
448
449        cfg->fc_scope = RT_SCOPE_NOWHERE;
450        cfg->fc_type = RTN_UNICAST;
451
452        if (rt->rt_dev) {
453                char *colon;
454                struct net_device *dev;
455                char devname[IFNAMSIZ];
456
457                if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
458                        return -EFAULT;
459
460                devname[IFNAMSIZ-1] = 0;
461                colon = strchr(devname, ':');
462                if (colon)
463                        *colon = 0;
464                dev = __dev_get_by_name(net, devname);
465                if (!dev)
466                        return -ENODEV;
467                cfg->fc_oif = dev->ifindex;
468                if (colon) {
469                        struct in_ifaddr *ifa;
470                        struct in_device *in_dev = __in_dev_get_rtnl(dev);
471                        if (!in_dev)
472                                return -ENODEV;
473                        *colon = ':';
474                        for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
475                                if (strcmp(ifa->ifa_label, devname) == 0)
476                                        break;
477                        if (!ifa)
478                                return -ENODEV;
479                        cfg->fc_prefsrc = ifa->ifa_local;
480                }
481        }
482
483        addr = sk_extract_addr(&rt->rt_gateway);
484        if (rt->rt_gateway.sa_family == AF_INET && addr) {
485                cfg->fc_gw = addr;
486                if (rt->rt_flags & RTF_GATEWAY &&
487                    inet_addr_type(net, addr) == RTN_UNICAST)
488                        cfg->fc_scope = RT_SCOPE_UNIVERSE;
489        }
490
491        if (cmd == SIOCDELRT)
492                return 0;
493
494        if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
495                return -EINVAL;
496
497        if (cfg->fc_scope == RT_SCOPE_NOWHERE)
498                cfg->fc_scope = RT_SCOPE_LINK;
499
500        if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
501                struct nlattr *mx;
502                int len = 0;
503
504                mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
505                if (!mx)
506                        return -ENOMEM;
507
508                if (rt->rt_flags & RTF_MTU)
509                        len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
510
511                if (rt->rt_flags & RTF_WINDOW)
512                        len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
513
514                if (rt->rt_flags & RTF_IRTT)
515                        len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
516
517                cfg->fc_mx = mx;
518                cfg->fc_mx_len = len;
519        }
520
521        return 0;
522}
523
524/*
525 * Handle IP routing ioctl calls.
526 * These are used to manipulate the routing tables
527 */
528int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
529{
530        struct fib_config cfg;
531        struct rtentry rt;
532        int err;
533
534        switch (cmd) {
535        case SIOCADDRT:         /* Add a route */
536        case SIOCDELRT:         /* Delete a route */
537                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
538                        return -EPERM;
539
540                if (copy_from_user(&rt, arg, sizeof(rt)))
541                        return -EFAULT;
542
543                rtnl_lock();
544                err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
545                if (err == 0) {
546                        struct fib_table *tb;
547
548                        if (cmd == SIOCDELRT) {
549                                tb = fib_get_table(net, cfg.fc_table);
550                                if (tb)
551                                        err = fib_table_delete(tb, &cfg);
552                                else
553                                        err = -ESRCH;
554                        } else {
555                                tb = fib_new_table(net, cfg.fc_table);
556                                if (tb)
557                                        err = fib_table_insert(tb, &cfg);
558                                else
559                                        err = -ENOBUFS;
560                        }
561
562                        /* allocated by rtentry_to_fib_config() */
563                        kfree(cfg.fc_mx);
564                }
565                rtnl_unlock();
566                return err;
567        }
568        return -EINVAL;
569}
570
571const struct nla_policy rtm_ipv4_policy[RTA_MAX + 1] = {
572        [RTA_DST]               = { .type = NLA_U32 },
573        [RTA_SRC]               = { .type = NLA_U32 },
574        [RTA_IIF]               = { .type = NLA_U32 },
575        [RTA_OIF]               = { .type = NLA_U32 },
576        [RTA_GATEWAY]           = { .type = NLA_U32 },
577        [RTA_PRIORITY]          = { .type = NLA_U32 },
578        [RTA_PREFSRC]           = { .type = NLA_U32 },
579        [RTA_METRICS]           = { .type = NLA_NESTED },
580        [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
581        [RTA_FLOW]              = { .type = NLA_U32 },
582};
583
584static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
585                             struct nlmsghdr *nlh, struct fib_config *cfg)
586{
587        struct nlattr *attr;
588        int err, remaining;
589        struct rtmsg *rtm;
590
591        err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
592        if (err < 0)
593                goto errout;
594
595        memset(cfg, 0, sizeof(*cfg));
596
597        rtm = nlmsg_data(nlh);
598        cfg->fc_dst_len = rtm->rtm_dst_len;
599        cfg->fc_tos = rtm->rtm_tos;
600        cfg->fc_table = rtm->rtm_table;
601        cfg->fc_protocol = rtm->rtm_protocol;
602        cfg->fc_scope = rtm->rtm_scope;
603        cfg->fc_type = rtm->rtm_type;
604        cfg->fc_flags = rtm->rtm_flags;
605        cfg->fc_nlflags = nlh->nlmsg_flags;
606
607        cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
608        cfg->fc_nlinfo.nlh = nlh;
609        cfg->fc_nlinfo.nl_net = net;
610
611        if (cfg->fc_type > RTN_MAX) {
612                err = -EINVAL;
613                goto errout;
614        }
615
616        nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
617                switch (nla_type(attr)) {
618                case RTA_DST:
619                        cfg->fc_dst = nla_get_be32(attr);
620                        break;
621                case RTA_OIF:
622                        cfg->fc_oif = nla_get_u32(attr);
623                        break;
624                case RTA_GATEWAY:
625                        cfg->fc_gw = nla_get_be32(attr);
626                        break;
627                case RTA_PRIORITY:
628                        cfg->fc_priority = nla_get_u32(attr);
629                        break;
630                case RTA_PREFSRC:
631                        cfg->fc_prefsrc = nla_get_be32(attr);
632                        break;
633                case RTA_METRICS:
634                        cfg->fc_mx = nla_data(attr);
635                        cfg->fc_mx_len = nla_len(attr);
636                        break;
637                case RTA_MULTIPATH:
638                        cfg->fc_mp = nla_data(attr);
639                        cfg->fc_mp_len = nla_len(attr);
640                        break;
641                case RTA_FLOW:
642                        cfg->fc_flow = nla_get_u32(attr);
643                        break;
644                case RTA_TABLE:
645                        cfg->fc_table = nla_get_u32(attr);
646                        break;
647                }
648        }
649
650        return 0;
651errout:
652        return err;
653}
654
655static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
656{
657        struct net *net = sock_net(skb->sk);
658        struct fib_config cfg;
659        struct fib_table *tb;
660        int err;
661
662        err = rtm_to_fib_config(net, skb, nlh, &cfg);
663        if (err < 0)
664                goto errout;
665
666        tb = fib_get_table(net, cfg.fc_table);
667        if (!tb) {
668                err = -ESRCH;
669                goto errout;
670        }
671
672        err = fib_table_delete(tb, &cfg);
673errout:
674        return err;
675}
676
677static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
678{
679        struct net *net = sock_net(skb->sk);
680        struct fib_config cfg;
681        struct fib_table *tb;
682        int err;
683
684        err = rtm_to_fib_config(net, skb, nlh, &cfg);
685        if (err < 0)
686                goto errout;
687
688        tb = fib_new_table(net, cfg.fc_table);
689        if (!tb) {
690                err = -ENOBUFS;
691                goto errout;
692        }
693
694        err = fib_table_insert(tb, &cfg);
695errout:
696        return err;
697}
698
699static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
700{
701        struct net *net = sock_net(skb->sk);
702        unsigned int h, s_h;
703        unsigned int e = 0, s_e;
704        struct fib_table *tb;
705        struct hlist_head *head;
706        int dumped = 0;
707
708        if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
709            ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
710                return skb->len;
711
712        s_h = cb->args[0];
713        s_e = cb->args[1];
714
715        rcu_read_lock();
716
717        for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
718                e = 0;
719                head = &net->ipv4.fib_table_hash[h];
720                hlist_for_each_entry_rcu(tb, head, tb_hlist) {
721                        if (e < s_e)
722                                goto next;
723                        if (dumped)
724                                memset(&cb->args[2], 0, sizeof(cb->args) -
725                                                 2 * sizeof(cb->args[0]));
726                        if (fib_table_dump(tb, skb, cb) < 0)
727                                goto out;
728                        dumped = 1;
729next:
730                        e++;
731                }
732        }
733out:
734        rcu_read_unlock();
735
736        cb->args[1] = e;
737        cb->args[0] = h;
738
739        return skb->len;
740}
741
742/* Prepare and feed intra-kernel routing request.
743 * Really, it should be netlink message, but :-( netlink
744 * can be not configured, so that we feed it directly
745 * to fib engine. It is legal, because all events occur
746 * only when netlink is already locked.
747 */
748static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
749{
750        struct net *net = dev_net(ifa->ifa_dev->dev);
751        struct fib_table *tb;
752        struct fib_config cfg = {
753                .fc_protocol = RTPROT_KERNEL,
754                .fc_type = type,
755                .fc_dst = dst,
756                .fc_dst_len = dst_len,
757                .fc_prefsrc = ifa->ifa_local,
758                .fc_oif = ifa->ifa_dev->dev->ifindex,
759                .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
760                .fc_nlinfo = {
761                        .nl_net = net,
762                },
763        };
764
765        if (type == RTN_UNICAST)
766                tb = fib_new_table(net, RT_TABLE_MAIN);
767        else
768                tb = fib_new_table(net, RT_TABLE_LOCAL);
769
770        if (!tb)
771                return;
772
773        cfg.fc_table = tb->tb_id;
774
775        if (type != RTN_LOCAL)
776                cfg.fc_scope = RT_SCOPE_LINK;
777        else
778                cfg.fc_scope = RT_SCOPE_HOST;
779
780        if (cmd == RTM_NEWROUTE)
781                fib_table_insert(tb, &cfg);
782        else
783                fib_table_delete(tb, &cfg);
784}
785
786void fib_add_ifaddr(struct in_ifaddr *ifa)
787{
788        struct in_device *in_dev = ifa->ifa_dev;
789        struct net_device *dev = in_dev->dev;
790        struct in_ifaddr *prim = ifa;
791        __be32 mask = ifa->ifa_mask;
792        __be32 addr = ifa->ifa_local;
793        __be32 prefix = ifa->ifa_address & mask;
794
795        if (ifa->ifa_flags & IFA_F_SECONDARY) {
796                prim = inet_ifa_byprefix(in_dev, prefix, mask);
797                if (!prim) {
798                        pr_warn("%s: bug: prim == NULL\n", __func__);
799                        return;
800                }
801        }
802
803        fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
804
805        if (!(dev->flags & IFF_UP))
806                return;
807
808        /* Add broadcast address, if it is explicitly assigned. */
809        if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
810                fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
811
812        if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags & IFA_F_SECONDARY) &&
813            (prefix != addr || ifa->ifa_prefixlen < 32)) {
814                fib_magic(RTM_NEWROUTE,
815                          dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
816                          prefix, ifa->ifa_prefixlen, prim);
817
818                /* Add network specific broadcasts, when it takes a sense */
819                if (ifa->ifa_prefixlen < 31) {
820                        fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
821                        fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix | ~mask,
822                                  32, prim);
823                }
824        }
825}
826
827/* Delete primary or secondary address.
828 * Optionally, on secondary address promotion consider the addresses
829 * from subnet iprim as deleted, even if they are in device list.
830 * In this case the secondary ifa can be in device list.
831 */
832void fib_del_ifaddr(struct in_ifaddr *ifa, struct in_ifaddr *iprim)
833{
834        struct in_device *in_dev = ifa->ifa_dev;
835        struct net_device *dev = in_dev->dev;
836        struct in_ifaddr *ifa1;
837        struct in_ifaddr *prim = ifa, *prim1 = NULL;
838        __be32 brd = ifa->ifa_address | ~ifa->ifa_mask;
839        __be32 any = ifa->ifa_address & ifa->ifa_mask;
840#define LOCAL_OK        1
841#define BRD_OK          2
842#define BRD0_OK         4
843#define BRD1_OK         8
844        unsigned int ok = 0;
845        int subnet = 0;         /* Primary network */
846        int gone = 1;           /* Address is missing */
847        int same_prefsrc = 0;   /* Another primary with same IP */
848
849        if (ifa->ifa_flags & IFA_F_SECONDARY) {
850                prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
851                if (!prim) {
852                        pr_warn("%s: bug: prim == NULL\n", __func__);
853                        return;
854                }
855                if (iprim && iprim != prim) {
856                        pr_warn("%s: bug: iprim != prim\n", __func__);
857                        return;
858                }
859        } else if (!ipv4_is_zeronet(any) &&
860                   (any != ifa->ifa_local || ifa->ifa_prefixlen < 32)) {
861                fib_magic(RTM_DELROUTE,
862                          dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
863                          any, ifa->ifa_prefixlen, prim);
864                subnet = 1;
865        }
866
867        if (in_dev->dead)
868                goto no_promotions;
869
870        /* Deletion is more complicated than add.
871         * We should take care of not to delete too much :-)
872         *
873         * Scan address list to be sure that addresses are really gone.
874         */
875
876        for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
877                if (ifa1 == ifa) {
878                        /* promotion, keep the IP */
879                        gone = 0;
880                        continue;
881                }
882                /* Ignore IFAs from our subnet */
883                if (iprim && ifa1->ifa_mask == iprim->ifa_mask &&
884                    inet_ifa_match(ifa1->ifa_address, iprim))
885                        continue;
886
887                /* Ignore ifa1 if it uses different primary IP (prefsrc) */
888                if (ifa1->ifa_flags & IFA_F_SECONDARY) {
889                        /* Another address from our subnet? */
890                        if (ifa1->ifa_mask == prim->ifa_mask &&
891                            inet_ifa_match(ifa1->ifa_address, prim))
892                                prim1 = prim;
893                        else {
894                                /* We reached the secondaries, so
895                                 * same_prefsrc should be determined.
896                                 */
897                                if (!same_prefsrc)
898                                        continue;
899                                /* Search new prim1 if ifa1 is not
900                                 * using the current prim1
901                                 */
902                                if (!prim1 ||
903                                    ifa1->ifa_mask != prim1->ifa_mask ||
904                                    !inet_ifa_match(ifa1->ifa_address, prim1))
905                                        prim1 = inet_ifa_byprefix(in_dev,
906                                                        ifa1->ifa_address,
907                                                        ifa1->ifa_mask);
908                                if (!prim1)
909                                        continue;
910                                if (prim1->ifa_local != prim->ifa_local)
911                                        continue;
912                        }
913                } else {
914                        if (prim->ifa_local != ifa1->ifa_local)
915                                continue;
916                        prim1 = ifa1;
917                        if (prim != prim1)
918                                same_prefsrc = 1;
919                }
920                if (ifa->ifa_local == ifa1->ifa_local)
921                        ok |= LOCAL_OK;
922                if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
923                        ok |= BRD_OK;
924                if (brd == ifa1->ifa_broadcast)
925                        ok |= BRD1_OK;
926                if (any == ifa1->ifa_broadcast)
927                        ok |= BRD0_OK;
928                /* primary has network specific broadcasts */
929                if (prim1 == ifa1 && ifa1->ifa_prefixlen < 31) {
930                        __be32 brd1 = ifa1->ifa_address | ~ifa1->ifa_mask;
931                        __be32 any1 = ifa1->ifa_address & ifa1->ifa_mask;
932
933                        if (!ipv4_is_zeronet(any1)) {
934                                if (ifa->ifa_broadcast == brd1 ||
935                                    ifa->ifa_broadcast == any1)
936                                        ok |= BRD_OK;
937                                if (brd == brd1 || brd == any1)
938                                        ok |= BRD1_OK;
939                                if (any == brd1 || any == any1)
940                                        ok |= BRD0_OK;
941                        }
942                }
943        }
944
945no_promotions:
946        if (!(ok & BRD_OK))
947                fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
948        if (subnet && ifa->ifa_prefixlen < 31) {
949                if (!(ok & BRD1_OK))
950                        fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
951                if (!(ok & BRD0_OK))
952                        fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
953        }
954        if (!(ok & LOCAL_OK)) {
955                fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
956
957                /* Check, that this local address finally disappeared. */
958                if (gone &&
959                    inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
960                        /* And the last, but not the least thing.
961                         * We must flush stray FIB entries.
962                         *
963                         * First of all, we scan fib_info list searching
964                         * for stray nexthop entries, then ignite fib_flush.
965                         */
966                        if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
967                                fib_flush(dev_net(dev));
968                }
969        }
970#undef LOCAL_OK
971#undef BRD_OK
972#undef BRD0_OK
973#undef BRD1_OK
974}
975
976static void nl_fib_lookup(struct net *net, struct fib_result_nl *frn)
977{
978
979        struct fib_result       res;
980        struct flowi4           fl4 = {
981                .flowi4_mark = frn->fl_mark,
982                .daddr = frn->fl_addr,
983                .flowi4_tos = frn->fl_tos,
984                .flowi4_scope = frn->fl_scope,
985        };
986        struct fib_table *tb;
987
988        rcu_read_lock();
989
990        tb = fib_get_table(net, frn->tb_id_in);
991
992        frn->err = -ENOENT;
993        if (tb) {
994                local_bh_disable();
995
996                frn->tb_id = tb->tb_id;
997                frn->err = fib_table_lookup(tb, &fl4, &res, FIB_LOOKUP_NOREF);
998
999                if (!frn->err) {
1000                        frn->prefixlen = res.prefixlen;
1001                        frn->nh_sel = res.nh_sel;
1002                        frn->type = res.type;
1003                        frn->scope = res.scope;
1004                }
1005                local_bh_enable();
1006        }
1007
1008        rcu_read_unlock();
1009}
1010
1011static void nl_fib_input(struct sk_buff *skb)
1012{
1013        struct net *net;
1014        struct fib_result_nl *frn;
1015        struct nlmsghdr *nlh;
1016        u32 portid;
1017
1018        net = sock_net(skb->sk);
1019        nlh = nlmsg_hdr(skb);
1020        if (skb->len < nlmsg_total_size(sizeof(*frn)) ||
1021            skb->len < nlh->nlmsg_len ||
1022            nlmsg_len(nlh) < sizeof(*frn))
1023                return;
1024
1025        skb = netlink_skb_clone(skb, GFP_KERNEL);
1026        if (!skb)
1027                return;
1028        nlh = nlmsg_hdr(skb);
1029
1030        frn = (struct fib_result_nl *) nlmsg_data(nlh);
1031        nl_fib_lookup(net, frn);
1032
1033        portid = NETLINK_CB(skb).portid;      /* netlink portid */
1034        NETLINK_CB(skb).portid = 0;        /* from kernel */
1035        NETLINK_CB(skb).dst_group = 0;  /* unicast */
1036        netlink_unicast(net->ipv4.fibnl, skb, portid, MSG_DONTWAIT);
1037}
1038
1039static int __net_init nl_fib_lookup_init(struct net *net)
1040{
1041        struct sock *sk;
1042        struct netlink_kernel_cfg cfg = {
1043                .input  = nl_fib_input,
1044        };
1045
1046        sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, &cfg);
1047        if (!sk)
1048                return -EAFNOSUPPORT;
1049        net->ipv4.fibnl = sk;
1050        return 0;
1051}
1052
1053static void nl_fib_lookup_exit(struct net *net)
1054{
1055        netlink_kernel_release(net->ipv4.fibnl);
1056        net->ipv4.fibnl = NULL;
1057}
1058
1059static void fib_disable_ip(struct net_device *dev, int force)
1060{
1061        if (fib_sync_down_dev(dev, force))
1062                fib_flush(dev_net(dev));
1063        rt_cache_flush(dev_net(dev));
1064        arp_ifdown(dev);
1065}
1066
1067static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
1068{
1069        struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
1070        struct net_device *dev = ifa->ifa_dev->dev;
1071        struct net *net = dev_net(dev);
1072
1073        switch (event) {
1074        case NETDEV_UP:
1075                fib_add_ifaddr(ifa);
1076#ifdef CONFIG_IP_ROUTE_MULTIPATH
1077                fib_sync_up(dev);
1078#endif
1079                atomic_inc(&net->ipv4.dev_addr_genid);
1080                rt_cache_flush(dev_net(dev));
1081                break;
1082        case NETDEV_DOWN:
1083                fib_del_ifaddr(ifa, NULL);
1084                atomic_inc(&net->ipv4.dev_addr_genid);
1085                if (!ifa->ifa_dev->ifa_list) {
1086                        /* Last address was deleted from this interface.
1087                         * Disable IP.
1088                         */
1089                        fib_disable_ip(dev, 1);
1090                } else {
1091                        rt_cache_flush(dev_net(dev));
1092                }
1093                break;
1094        }
1095        return NOTIFY_DONE;
1096}
1097
1098static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1099{
1100        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1101        struct in_device *in_dev;
1102        struct net *net = dev_net(dev);
1103
1104        if (event == NETDEV_UNREGISTER) {
1105                fib_disable_ip(dev, 2);
1106                rt_flush_dev(dev);
1107                return NOTIFY_DONE;
1108        }
1109
1110        in_dev = __in_dev_get_rtnl(dev);
1111        if (!in_dev)
1112                return NOTIFY_DONE;
1113
1114        switch (event) {
1115        case NETDEV_UP:
1116                for_ifa(in_dev) {
1117                        fib_add_ifaddr(ifa);
1118                } endfor_ifa(in_dev);
1119#ifdef CONFIG_IP_ROUTE_MULTIPATH
1120                fib_sync_up(dev);
1121#endif
1122                atomic_inc(&net->ipv4.dev_addr_genid);
1123                rt_cache_flush(net);
1124                break;
1125        case NETDEV_DOWN:
1126                fib_disable_ip(dev, 0);
1127                break;
1128        case NETDEV_CHANGEMTU:
1129        case NETDEV_CHANGE:
1130                rt_cache_flush(net);
1131                break;
1132        }
1133        return NOTIFY_DONE;
1134}
1135
1136static struct notifier_block fib_inetaddr_notifier = {
1137        .notifier_call = fib_inetaddr_event,
1138};
1139
1140static struct notifier_block fib_netdev_notifier = {
1141        .notifier_call = fib_netdev_event,
1142};
1143
1144static int __net_init ip_fib_net_init(struct net *net)
1145{
1146        int err;
1147        size_t size = sizeof(struct hlist_head) * FIB_TABLE_HASHSZ;
1148
1149        /* Avoid false sharing : Use at least a full cache line */
1150        size = max_t(size_t, size, L1_CACHE_BYTES);
1151
1152        net->ipv4.fib_table_hash = kzalloc(size, GFP_KERNEL);
1153        if (!net->ipv4.fib_table_hash)
1154                return -ENOMEM;
1155
1156        err = fib4_rules_init(net);
1157        if (err < 0)
1158                goto fail;
1159        return 0;
1160
1161fail:
1162        kfree(net->ipv4.fib_table_hash);
1163        return err;
1164}
1165
1166static void ip_fib_net_exit(struct net *net)
1167{
1168        unsigned int i;
1169
1170        rtnl_lock();
1171#ifdef CONFIG_IP_MULTIPLE_TABLES
1172        RCU_INIT_POINTER(net->ipv4.fib_local, NULL);
1173        RCU_INIT_POINTER(net->ipv4.fib_main, NULL);
1174        RCU_INIT_POINTER(net->ipv4.fib_default, NULL);
1175#endif
1176
1177        for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1178                struct hlist_head *head = &net->ipv4.fib_table_hash[i];
1179                struct hlist_node *tmp;
1180                struct fib_table *tb;
1181
1182                hlist_for_each_entry_safe(tb, tmp, head, tb_hlist) {
1183                        hlist_del(&tb->tb_hlist);
1184                        fib_table_flush(tb);
1185                        fib_free_table(tb);
1186                }
1187        }
1188#ifdef CONFIG_IP_MULTIPLE_TABLES
1189        fib4_rules_exit(net);
1190#endif
1191        rtnl_unlock();
1192        kfree(net->ipv4.fib_table_hash);
1193}
1194
1195static int __net_init fib_net_init(struct net *net)
1196{
1197        int error;
1198
1199#ifdef CONFIG_IP_ROUTE_CLASSID
1200        net->ipv4.fib_num_tclassid_users = 0;
1201#endif
1202        error = ip_fib_net_init(net);
1203        if (error < 0)
1204                goto out;
1205        error = nl_fib_lookup_init(net);
1206        if (error < 0)
1207                goto out_nlfl;
1208        error = fib_proc_init(net);
1209        if (error < 0)
1210                goto out_proc;
1211out:
1212        return error;
1213
1214out_proc:
1215        nl_fib_lookup_exit(net);
1216out_nlfl:
1217        ip_fib_net_exit(net);
1218        goto out;
1219}
1220
1221static void __net_exit fib_net_exit(struct net *net)
1222{
1223        fib_proc_exit(net);
1224        nl_fib_lookup_exit(net);
1225        ip_fib_net_exit(net);
1226}
1227
1228static struct pernet_operations fib_net_ops = {
1229        .init = fib_net_init,
1230        .exit = fib_net_exit,
1231};
1232
1233void __init ip_fib_init(void)
1234{
1235        rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL, NULL);
1236        rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL, NULL);
1237        rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib, NULL);
1238
1239        register_pernet_subsys(&fib_net_ops);
1240        register_netdevice_notifier(&fib_netdev_notifier);
1241        register_inetaddr_notifier(&fib_inetaddr_notifier);
1242
1243        fib_trie_init();
1244}
Note: See TracBrowser for help on using the repository browser.