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