SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ipv4/fib_frontend.c

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