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