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 #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 static inline __be32 sk_extract_addr(struct sockaddr *addr)
 254 {
 255         return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
 256 }
 257
 258 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
 259 {
 260         struct nlattr *nla;
 261
 262         nla = (struct nlattr *) ((char *) mx + len);
 263         nla->nla_type = type;
 264         nla->nla_len = nla_attr_size(4);
 265         *(u32 *) nla_data(nla) = value;
 266
 267         return len + nla_total_size(4);
 268 }
 269
 270 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
 271                                  struct fib_config *cfg)
 272 {
 273         __be32 addr;
 274         int plen;
 275
 276         memset(cfg, 0, sizeof(*cfg));
 277
 278         if (rt->rt_dst.sa_family != AF_INET)
 279                 return -EAFNOSUPPORT;
 280
 281         /*
 282          * Check mask for validity:
 283          * a) it must be contiguous.
 284          * b) destination must have all host bits clear.
 285          * c) if application forgot to set correct family (AF_INET),
 286          *    reject request unless it is absolutely clear i.e.
 287          *    both family and mask are zero.
 288          */
 289         plen = 32;
 290         addr = sk_extract_addr(&rt->rt_dst);
 291         if (!(rt->rt_flags & RTF_HOST)) {
 292                 __be32 mask = sk_extract_addr(&rt->rt_genmask);
 293
 294                 if (rt->rt_genmask.sa_family != AF_INET) {
 295                         if (mask || rt->rt_genmask.sa_family)
 296                                 return -EAFNOSUPPORT;
 297                 }
 298
 299                 if (bad_mask(mask, addr))
 300                         return -EINVAL;
 301
 302                 plen = inet_mask_len(mask);
 303         }
 304
 305         cfg->fc_dst_len = plen;
 306         cfg->fc_dst = addr;
 307
 308         if (cmd != SIOCDELRT) {
 309                 cfg->fc_nlflags = NLM_F_CREATE;
 310                 cfg->fc_protocol = RTPROT_BOOT;
 311         }
 312
 313         if (rt->rt_metric)
 314                 cfg->fc_priority = rt->rt_metric - 1;
 315
 316         if (rt->rt_flags & RTF_REJECT) {
 317                 cfg->fc_scope = RT_SCOPE_HOST;
 318                 cfg->fc_type = RTN_UNREACHABLE;
 319                 return 0;
 320         }
 321
 322         cfg->fc_scope = RT_SCOPE_NOWHERE;
 323         cfg->fc_type = RTN_UNICAST;
 324
 325         if (rt->rt_dev) {
 326                 char *colon;
 327                 struct net_device *dev;
 328                 char devname[IFNAMSIZ];
 329
 330                 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
 331                         return -EFAULT;
 332
 333                 devname[IFNAMSIZ-1] = 0;
 334                 colon = strchr(devname, ':');
 335                 if (colon)
 336                         *colon = 0;
 337                 dev = __dev_get_by_name(devname);
 338                 if (!dev)
 339                         return -ENODEV;
 340                 cfg->fc_oif = dev->ifindex;
 341                 if (colon) {
 342                         struct in_ifaddr *ifa;
 343                         struct in_device *in_dev = __in_dev_get_rtnl(dev);
 344                         if (!in_dev)
 345                                 return -ENODEV;
 346                         *colon = ':';
 347                         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
 348                                 if (strcmp(ifa->ifa_label, devname) == 0)
 349                                         break;
 350                         if (ifa == NULL)
 351                                 return -ENODEV;
 352                         cfg->fc_prefsrc = ifa->ifa_local;
 353                 }
 354         }
 355
 356         addr = sk_extract_addr(&rt->rt_gateway);
 357         if (rt->rt_gateway.sa_family == AF_INET && addr) {
 358                 cfg->fc_gw = addr;
 359                 if (rt->rt_flags & RTF_GATEWAY &&
 360                     inet_addr_type(addr) == RTN_UNICAST)
 361                         cfg->fc_scope = RT_SCOPE_UNIVERSE;
 362         }
 363
 364         if (cmd == SIOCDELRT)
 365                 return 0;
 366
 367         if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
 368                 return -EINVAL;
 369
 370         if (cfg->fc_scope == RT_SCOPE_NOWHERE)
 371                 cfg->fc_scope = RT_SCOPE_LINK;
 372
 373         if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
 374                 struct nlattr *mx;
 375                 int len = 0;
 376
 377                 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
 378                 if (mx == NULL)
 379                         return -ENOMEM;
 380
 381                 if (rt->rt_flags & RTF_MTU)
 382                         len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
 383
 384                 if (rt->rt_flags & RTF_WINDOW)
 385                         len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
 386
 387                 if (rt->rt_flags & RTF_IRTT)
 388                         len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
 389
 390                 cfg->fc_mx = mx;
 391                 cfg->fc_mx_len = len;
 392         }
 393
 394         return 0;
 395 }
 396
 397 /*
 398  *      Handle IP routing ioctl calls. These are used to manipulate the routing tables
 399  */
 400
 401 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
 402 {
 403         struct fib_config cfg;
 404         struct rtentry rt;
 405         int err;
 406
 407         switch (cmd) {
 408         case SIOCADDRT:         /* Add a route */
 409         case SIOCDELRT:         /* Delete a route */
 410                 if (!capable(CAP_NET_ADMIN))
 411                         return -EPERM;
 412
 413                 if (copy_from_user(&rt, arg, sizeof(rt)))
 414                         return -EFAULT;
 415
 416                 rtnl_lock();
 417                 err = rtentry_to_fib_config(cmd, &rt, &cfg);
 418                 if (err == 0) {
 419                         struct fib_table *tb;
 420
 421                         if (cmd == SIOCDELRT) {
 422                                 tb = fib_get_table(cfg.fc_table);
 423                                 if (tb)
 424                                         err = tb->tb_delete(tb, &cfg);
 425                                 else
 426                                         err = -ESRCH;
 427                         } else {
 428                                 tb = fib_new_table(cfg.fc_table);
 429                                 if (tb)
 430                                         err = tb->tb_insert(tb, &cfg);
 431                                 else
 432                                         err = -ENOBUFS;
 433                         }
 434
 435                         /* allocated by rtentry_to_fib_config() */
 436                         kfree(cfg.fc_mx);
 437                 }
 438                 rtnl_unlock();
 439                 return err;
 440         }
 441         return -EINVAL;
 442 }
 443
 444 struct nla_policy rtm_ipv4_policy[RTA_MAX+1] __read_mostly = {
 445         [RTA_DST]               = { .type = NLA_U32 },
 446         [RTA_SRC]               = { .type = NLA_U32 },
 447         [RTA_IIF]               = { .type = NLA_U32 },
 448         [RTA_OIF]               = { .type = NLA_U32 },
 449         [RTA_GATEWAY]           = { .type = NLA_U32 },
 450         [RTA_PRIORITY]          = { .type = NLA_U32 },
 451         [RTA_PREFSRC]           = { .type = NLA_U32 },
 452         [RTA_METRICS]           = { .type = NLA_NESTED },
 453         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
 454         [RTA_PROTOINFO]         = { .type = NLA_U32 },
 455         [RTA_FLOW]              = { .type = NLA_U32 },
 456         [RTA_MP_ALGO]           = { .type = NLA_U32 },
 457 };
 458
 459 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
 460                              struct fib_config *cfg)
 461 {
 462         struct nlattr *attr;
 463         int err, remaining;
 464         struct rtmsg *rtm;
 465
 466         err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
 467         if (err < 0)
 468                 goto errout;
 469
 470         memset(cfg, 0, sizeof(*cfg));
 471
 472         rtm = nlmsg_data(nlh);
 473         cfg->fc_dst_len = rtm->rtm_dst_len;
 474         cfg->fc_tos = rtm->rtm_tos;
 475         cfg->fc_table = rtm->rtm_table;
 476         cfg->fc_protocol = rtm->rtm_protocol;
 477         cfg->fc_scope = rtm->rtm_scope;
 478         cfg->fc_type = rtm->rtm_type;
 479         cfg->fc_flags = rtm->rtm_flags;
 480         cfg->fc_nlflags = nlh->nlmsg_flags;
 481
 482         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
 483         cfg->fc_nlinfo.nlh = nlh;
 484
 485         if (cfg->fc_type > RTN_MAX) {
 486                 err = -EINVAL;
 487                 goto errout;
 488         }
 489
 490         nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
 491                 switch (attr->nla_type) {
 492                 case RTA_DST:
 493                         cfg->fc_dst = nla_get_be32(attr);
 494                         break;
 495                 case RTA_OIF:
 496                         cfg->fc_oif = nla_get_u32(attr);
 497                         break;
 498                 case RTA_GATEWAY:
 499                         cfg->fc_gw = nla_get_be32(attr);
 500                         break;
 501                 case RTA_PRIORITY:
 502                         cfg->fc_priority = nla_get_u32(attr);
 503                         break;
 504                 case RTA_PREFSRC:
 505                         cfg->fc_prefsrc = nla_get_be32(attr);
 506                         break;
 507                 case RTA_METRICS:
 508                         cfg->fc_mx = nla_data(attr);
 509                         cfg->fc_mx_len = nla_len(attr);
 510                         break;
 511                 case RTA_MULTIPATH:
 512                         cfg->fc_mp = nla_data(attr);
 513                         cfg->fc_mp_len = nla_len(attr);
 514                         break;
 515                 case RTA_FLOW:
 516                         cfg->fc_flow = nla_get_u32(attr);
 517                         break;
 518                 case RTA_MP_ALGO:
 519                         cfg->fc_mp_alg = 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 sock *sk, int len)
 792 {
 793         struct sk_buff *skb = NULL;
 794         struct nlmsghdr *nlh = NULL;
 795         struct fib_result_nl *frn;
 796         u32 pid;
 797         struct fib_table *tb;
 798
 799         skb = skb_dequeue(&sk->sk_receive_queue);
 800         if (skb == NULL)
 801                 return;
 802
 803         nlh = nlmsg_hdr(skb);
 804         if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
 805             nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) {
 806                 kfree_skb(skb);
 807                 return;
 808         }
 809
 810         frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
 811         tb = fib_get_table(frn->tb_id_in);
 812
 813         nl_fib_lookup(frn, tb);
 814
 815         pid = NETLINK_CB(skb).pid;       /* pid of sending process */
 816         NETLINK_CB(skb).pid = 0;         /* from kernel */
 817         NETLINK_CB(skb).dst_group = 0;  /* unicast */
 818         netlink_unicast(sk, skb, pid, MSG_DONTWAIT);
 819 }
 820
 821 static void nl_fib_lookup_init(void)
 822 {
 823       netlink_kernel_create(NETLINK_FIB_LOOKUP, 0, nl_fib_input, NULL,
 824                             THIS_MODULE);
 825 }
 826
 827 static void fib_disable_ip(struct net_device *dev, int force)
 828 {
 829         if (fib_sync_down(0, dev, force))
 830                 fib_flush();
 831         rt_cache_flush(0);
 832         arp_ifdown(dev);
 833 }
 834
 835 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
 836 {
 837         struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
 838
 839         switch (event) {
 840         case NETDEV_UP:
 841                 fib_add_ifaddr(ifa);
 842 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 843                 fib_sync_up(ifa->ifa_dev->dev);
 844 #endif
 845                 rt_cache_flush(-1);
 846                 break;
 847         case NETDEV_DOWN:
 848                 fib_del_ifaddr(ifa);
 849                 if (ifa->ifa_dev->ifa_list == NULL) {
 850                         /* Last address was deleted from this interface.
 851                            Disable IP.
 852                          */
 853                         fib_disable_ip(ifa->ifa_dev->dev, 1);
 854                 } else {
 855                         rt_cache_flush(-1);
 856                 }
 857                 break;
 858         }
 859         return NOTIFY_DONE;
 860 }
 861
 862 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 863 {
 864         struct net_device *dev = ptr;
 865         struct in_device *in_dev = __in_dev_get_rtnl(dev);
 866
 867         if (event == NETDEV_UNREGISTER) {
 868                 fib_disable_ip(dev, 2);
 869                 return NOTIFY_DONE;
 870         }
 871
 872         if (!in_dev)
 873                 return NOTIFY_DONE;
 874
 875         switch (event) {
 876         case NETDEV_UP:
 877                 for_ifa(in_dev) {
 878                         fib_add_ifaddr(ifa);
 879                 } endfor_ifa(in_dev);
 880 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 881                 fib_sync_up(dev);
 882 #endif
 883                 rt_cache_flush(-1);
 884                 break;
 885         case NETDEV_DOWN:
 886                 fib_disable_ip(dev, 0);
 887                 break;
 888         case NETDEV_CHANGEMTU:
 889         case NETDEV_CHANGE:
 890                 rt_cache_flush(0);
 891                 break;
 892         }
 893         return NOTIFY_DONE;
 894 }
 895
 896 static struct notifier_block fib_inetaddr_notifier = {
 897         .notifier_call =fib_inetaddr_event,
 898 };
 899
 900 static struct notifier_block fib_netdev_notifier = {
 901         .notifier_call =fib_netdev_event,
 902 };
 903
 904 void __init ip_fib_init(void)
 905 {
 906         unsigned int i;
 907
 908         for (i = 0; i < FIB_TABLE_HASHSZ; i++)
 909                 INIT_HLIST_HEAD(&fib_table_hash[i]);
 910 #ifndef CONFIG_IP_MULTIPLE_TABLES
 911         ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
 912         hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
 913         ip_fib_main_table  = fib_hash_init(RT_TABLE_MAIN);
 914         hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
 915 #else
 916         fib4_rules_init();
 917 #endif
 918
 919         register_netdevice_notifier(&fib_netdev_notifier);
 920         register_inetaddr_notifier(&fib_inetaddr_notifier);
 921         nl_fib_lookup_init();
 922
 923         rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
 924         rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
 925         rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
 926 }
 927
 928 EXPORT_SYMBOL(inet_addr_type);
 929 EXPORT_SYMBOL(ip_dev_find);