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