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