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
 132 #ifdef CONFIG_IP_MULTIPLE_TABLES
 133         res.r = NULL;
 134 #endif
 135
 136         if (!ip_fib_local_table ||
 137             ip_fib_local_table->tb_lookup(ip_fib_local_table, &fl, &res))
 138                 return NULL;
 139         if (res.type != RTN_LOCAL)
 140                 goto out;
 141         dev = FIB_RES_DEV(res);
 142
 143         if (dev)
 144                 dev_hold(dev);
 145 out:
 146         fib_res_put(&res);
 147         return dev;
 148 }
 149
 150 unsigned inet_addr_type(__be32 addr)
 151 {
 152         struct flowi            fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
 153         struct fib_result       res;
 154         unsigned ret = RTN_BROADCAST;
 155
 156         if (ZERONET(addr) || BADCLASS(addr))
 157                 return RTN_BROADCAST;
 158         if (MULTICAST(addr))
 159                 return RTN_MULTICAST;
 160
 161 #ifdef CONFIG_IP_MULTIPLE_TABLES
 162         res.r = NULL;
 163 #endif
 164
 165         if (ip_fib_local_table) {
 166                 ret = RTN_UNICAST;
 167                 if (!ip_fib_local_table->tb_lookup(ip_fib_local_table,
 168                                                    &fl, &res)) {
 169                         ret = res.type;
 170                         fib_res_put(&res);
 171                 }
 172         }
 173         return ret;
 174 }
 175
 176 /* Given (packet source, input interface) and optional (dst, oif, tos):
 177    - (main) check, that source is valid i.e. not broadcast or our local
 178      address.
 179    - figure out what "logical" interface this packet arrived
 180      and calculate "specific destination" address.
 181    - check, that packet arrived from expected physical interface.
 182  */
 183
 184 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
 185                         struct net_device *dev, __be32 *spec_dst, u32 *itag)
 186 {
 187         struct in_device *in_dev;
 188         struct flowi fl = { .nl_u = { .ip4_u =
 189                                       { .daddr = src,
 190                                         .saddr = dst,
 191                                         .tos = tos } },
 192                             .iif = oif };
 193         struct fib_result res;
 194         int no_addr, rpf;
 195         int ret;
 196
 197         no_addr = rpf = 0;
 198         rcu_read_lock();
 199         in_dev = __in_dev_get_rcu(dev);
 200         if (in_dev) {
 201                 no_addr = in_dev->ifa_list == NULL;
 202                 rpf = IN_DEV_RPFILTER(in_dev);
 203         }
 204         rcu_read_unlock();
 205
 206         if (in_dev == NULL)
 207                 goto e_inval;
 208
 209         if (fib_lookup(&fl, &res))
 210                 goto last_resort;
 211         if (res.type != RTN_UNICAST)
 212                 goto e_inval_res;
 213         *spec_dst = FIB_RES_PREFSRC(res);
 214         fib_combine_itag(itag, &res);
 215 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 216         if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
 217 #else
 218         if (FIB_RES_DEV(res) == dev)
 219 #endif
 220         {
 221                 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 222                 fib_res_put(&res);
 223                 return ret;
 224         }
 225         fib_res_put(&res);
 226         if (no_addr)
 227                 goto last_resort;
 228         if (rpf)
 229                 goto e_inval;
 230         fl.oif = dev->ifindex;
 231
 232         ret = 0;
 233         if (fib_lookup(&fl, &res) == 0) {
 234                 if (res.type == RTN_UNICAST) {
 235                         *spec_dst = FIB_RES_PREFSRC(res);
 236                         ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 237                 }
 238                 fib_res_put(&res);
 239         }
 240         return ret;
 241
 242 last_resort:
 243         if (rpf)
 244                 goto e_inval;
 245         *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
 246         *itag = 0;
 247         return 0;
 248
 249 e_inval_res:
 250         fib_res_put(&res);
 251 e_inval:
 252         return -EINVAL;
 253 }
 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(&init_net, 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 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
 447         [RTA_DST]               = { .type = NLA_U32 },
 448         [RTA_SRC]               = { .type = NLA_U32 },
 449         [RTA_IIF]               = { .type = NLA_U32 },
 450         [RTA_OIF]               = { .type = NLA_U32 },
 451         [RTA_GATEWAY]           = { .type = NLA_U32 },
 452         [RTA_PRIORITY]          = { .type = NLA_U32 },
 453         [RTA_PREFSRC]           = { .type = NLA_U32 },
 454         [RTA_METRICS]           = { .type = NLA_NESTED },
 455         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
 456         [RTA_PROTOINFO]         = { .type = NLA_U32 },
 457         [RTA_FLOW]              = { .type = NLA_U32 },
 458 };
 459
 460 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
 461                              struct fib_config *cfg)
 462 {
 463         struct nlattr *attr;
 464         int err, remaining;
 465         struct rtmsg *rtm;
 466
 467         err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
 468         if (err < 0)
 469                 goto errout;
 470
 471         memset(cfg, 0, sizeof(*cfg));
 472
 473         rtm = nlmsg_data(nlh);
 474         cfg->fc_dst_len = rtm->rtm_dst_len;
 475         cfg->fc_tos = rtm->rtm_tos;
 476         cfg->fc_table = rtm->rtm_table;
 477         cfg->fc_protocol = rtm->rtm_protocol;
 478         cfg->fc_scope = rtm->rtm_scope;
 479         cfg->fc_type = rtm->rtm_type;
 480         cfg->fc_flags = rtm->rtm_flags;
 481         cfg->fc_nlflags = nlh->nlmsg_flags;
 482
 483         cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
 484         cfg->fc_nlinfo.nlh = nlh;
 485
 486         if (cfg->fc_type > RTN_MAX) {
 487                 err = -EINVAL;
 488                 goto errout;
 489         }
 490
 491         nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
 492                 switch (nla_type(attr)) {
 493                 case RTA_DST:
 494                         cfg->fc_dst = nla_get_be32(attr);
 495                         break;
 496                 case RTA_OIF:
 497                         cfg->fc_oif = nla_get_u32(attr);
 498                         break;
 499                 case RTA_GATEWAY:
 500                         cfg->fc_gw = nla_get_be32(attr);
 501                         break;
 502                 case RTA_PRIORITY:
 503                         cfg->fc_priority = nla_get_u32(attr);
 504                         break;
 505                 case RTA_PREFSRC:
 506                         cfg->fc_prefsrc = nla_get_be32(attr);
 507                         break;
 508                 case RTA_METRICS:
 509                         cfg->fc_mx = nla_data(attr);
 510                         cfg->fc_mx_len = nla_len(attr);
 511                         break;
 512                 case RTA_MULTIPATH:
 513                         cfg->fc_mp = nla_data(attr);
 514                         cfg->fc_mp_len = nla_len(attr);
 515                         break;
 516                 case RTA_FLOW:
 517                         cfg->fc_flow = nla_get_u32(attr);
 518                         break;
 519                 case RTA_TABLE:
 520                         cfg->fc_table = nla_get_u32(attr);
 521                         break;
 522                 }
 523         }
 524
 525         return 0;
 526 errout:
 527         return err;
 528 }
 529
 530 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 531 {
 532         struct fib_config cfg;
 533         struct fib_table *tb;
 534         int err;
 535
 536         err = rtm_to_fib_config(skb, nlh, &cfg);
 537         if (err < 0)
 538                 goto errout;
 539
 540         tb = fib_get_table(cfg.fc_table);
 541         if (tb == NULL) {
 542                 err = -ESRCH;
 543                 goto errout;
 544         }
 545
 546         err = tb->tb_delete(tb, &cfg);
 547 errout:
 548         return err;
 549 }
 550
 551 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 552 {
 553         struct fib_config cfg;
 554         struct fib_table *tb;
 555         int err;
 556
 557         err = rtm_to_fib_config(skb, nlh, &cfg);
 558         if (err < 0)
 559                 goto errout;
 560
 561         tb = fib_new_table(cfg.fc_table);
 562         if (tb == NULL) {
 563                 err = -ENOBUFS;
 564                 goto errout;
 565         }
 566
 567         err = tb->tb_insert(tb, &cfg);
 568 errout:
 569         return err;
 570 }
 571
 572 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
 573 {
 574         unsigned int h, s_h;
 575         unsigned int e = 0, s_e;
 576         struct fib_table *tb;
 577         struct hlist_node *node;
 578         int dumped = 0;
 579
 580         if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
 581             ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
 582                 return ip_rt_dump(skb, cb);
 583
 584         s_h = cb->args[0];
 585         s_e = cb->args[1];
 586
 587         for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
 588                 e = 0;
 589                 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
 590                         if (e < s_e)
 591                                 goto next;
 592                         if (dumped)
 593                                 memset(&cb->args[2], 0, sizeof(cb->args) -
 594                                                  2 * sizeof(cb->args[0]));
 595                         if (tb->tb_dump(tb, skb, cb) < 0)
 596                                 goto out;
 597                         dumped = 1;
 598 next:
 599                         e++;
 600                 }
 601         }
 602 out:
 603         cb->args[1] = e;
 604         cb->args[0] = h;
 605
 606         return skb->len;
 607 }
 608
 609 /* Prepare and feed intra-kernel routing request.
 610    Really, it should be netlink message, but :-( netlink
 611    can be not configured, so that we feed it directly
 612    to fib engine. It is legal, because all events occur
 613    only when netlink is already locked.
 614  */
 615
 616 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
 617 {
 618         struct fib_table *tb;
 619         struct fib_config cfg = {
 620                 .fc_protocol = RTPROT_KERNEL,
 621                 .fc_type = type,
 622                 .fc_dst = dst,
 623                 .fc_dst_len = dst_len,
 624                 .fc_prefsrc = ifa->ifa_local,
 625                 .fc_oif = ifa->ifa_dev->dev->ifindex,
 626                 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
 627         };
 628
 629         if (type == RTN_UNICAST)
 630                 tb = fib_new_table(RT_TABLE_MAIN);
 631         else
 632                 tb = fib_new_table(RT_TABLE_LOCAL);
 633
 634         if (tb == NULL)
 635                 return;
 636
 637         cfg.fc_table = tb->tb_id;
 638
 639         if (type != RTN_LOCAL)
 640                 cfg.fc_scope = RT_SCOPE_LINK;
 641         else
 642                 cfg.fc_scope = RT_SCOPE_HOST;
 643
 644         if (cmd == RTM_NEWROUTE)
 645                 tb->tb_insert(tb, &cfg);
 646         else
 647                 tb->tb_delete(tb, &cfg);
 648 }
 649
 650 void fib_add_ifaddr(struct in_ifaddr *ifa)
 651 {
 652         struct in_device *in_dev = ifa->ifa_dev;
 653         struct net_device *dev = in_dev->dev;
 654         struct in_ifaddr *prim = ifa;
 655         __be32 mask = ifa->ifa_mask;
 656         __be32 addr = ifa->ifa_local;
 657         __be32 prefix = ifa->ifa_address&mask;
 658
 659         if (ifa->ifa_flags&IFA_F_SECONDARY) {
 660                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
 661                 if (prim == NULL) {
 662                         printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
 663                         return;
 664                 }
 665         }
 666
 667         fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
 668
 669         if (!(dev->flags&IFF_UP))
 670                 return;
 671
 672         /* Add broadcast address, if it is explicitly assigned. */
 673         if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
 674                 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 675
 676         if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
 677             (prefix != addr || ifa->ifa_prefixlen < 32)) {
 678                 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 679                           RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
 680
 681                 /* Add network specific broadcasts, when it takes a sense */
 682                 if (ifa->ifa_prefixlen < 31) {
 683                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
 684                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
 685                 }
 686         }
 687 }
 688
 689 static void fib_del_ifaddr(struct in_ifaddr *ifa)
 690 {
 691         struct in_device *in_dev = ifa->ifa_dev;
 692         struct net_device *dev = in_dev->dev;
 693         struct in_ifaddr *ifa1;
 694         struct in_ifaddr *prim = ifa;
 695         __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
 696         __be32 any = ifa->ifa_address&ifa->ifa_mask;
 697 #define LOCAL_OK        1
 698 #define BRD_OK          2
 699 #define BRD0_OK         4
 700 #define BRD1_OK         8
 701         unsigned ok = 0;
 702
 703         if (!(ifa->ifa_flags&IFA_F_SECONDARY))
 704                 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 705                           RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
 706         else {
 707                 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
 708                 if (prim == NULL) {
 709                         printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
 710                         return;
 711                 }
 712         }
 713
 714         /* Deletion is more complicated than add.
 715            We should take care of not to delete too much :-)
 716
 717            Scan address list to be sure that addresses are really gone.
 718          */
 719
 720         for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
 721                 if (ifa->ifa_local == ifa1->ifa_local)
 722                         ok |= LOCAL_OK;
 723                 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
 724                         ok |= BRD_OK;
 725                 if (brd == ifa1->ifa_broadcast)
 726                         ok |= BRD1_OK;
 727                 if (any == ifa1->ifa_broadcast)
 728                         ok |= BRD0_OK;
 729         }
 730
 731         if (!(ok&BRD_OK))
 732                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 733         if (!(ok&BRD1_OK))
 734                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
 735         if (!(ok&BRD0_OK))
 736                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
 737         if (!(ok&LOCAL_OK)) {
 738                 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
 739
 740                 /* Check, that this local address finally disappeared. */
 741                 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
 742                         /* And the last, but not the least thing.
 743                            We must flush stray FIB entries.
 744
 745                            First of all, we scan fib_info list searching
 746                            for stray nexthop entries, then ignite fib_flush.
 747                         */
 748                         if (fib_sync_down(ifa->ifa_local, NULL, 0))
 749                                 fib_flush();
 750                 }
 751         }
 752 #undef LOCAL_OK
 753 #undef BRD_OK
 754 #undef BRD0_OK
 755 #undef BRD1_OK
 756 }
 757
 758 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
 759 {
 760
 761         struct fib_result       res;
 762         struct flowi            fl = { .mark = frn->fl_mark,
 763                                        .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
 764                                                             .tos = frn->fl_tos,
 765                                                             .scope = frn->fl_scope } } };
 766
 767 #ifdef CONFIG_IP_MULTIPLE_TABLES
 768         res.r = NULL;
 769 #endif
 770
 771         frn->err = -ENOENT;
 772         if (tb) {
 773                 local_bh_disable();
 774
 775                 frn->tb_id = tb->tb_id;
 776                 frn->err = tb->tb_lookup(tb, &fl, &res);
 777
 778                 if (!frn->err) {
 779                         frn->prefixlen = res.prefixlen;
 780                         frn->nh_sel = res.nh_sel;
 781                         frn->type = res.type;
 782                         frn->scope = res.scope;
 783                         fib_res_put(&res);
 784                 }
 785                 local_bh_enable();
 786         }
 787 }
 788
 789 static void nl_fib_input(struct sk_buff *skb)
 790 {
 791         struct fib_result_nl *frn;
 792         struct nlmsghdr *nlh;
 793         struct fib_table *tb;
 794         u32 pid;
 795
 796         nlh = nlmsg_hdr(skb);
 797         if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
 798             nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) {
 799                 kfree_skb(skb);
 800                 return;
 801         }
 802
 803         frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
 804         tb = fib_get_table(frn->tb_id_in);
 805
 806         nl_fib_lookup(frn, tb);
 807
 808         pid = NETLINK_CB(skb).pid;       /* pid of sending process */
 809         NETLINK_CB(skb).pid = 0;         /* from kernel */
 810         NETLINK_CB(skb).dst_group = 0;  /* unicast */
 811         netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
 812 }
 813
 814 static void nl_fib_lookup_init(void)
 815 {
 816         fibnl = netlink_kernel_create(&init_net, NETLINK_FIB_LOOKUP, 0,
 817                                       nl_fib_input, NULL, THIS_MODULE);
 818 }
 819
 820 static void fib_disable_ip(struct net_device *dev, int force)
 821 {
 822         if (fib_sync_down(0, dev, force))
 823                 fib_flush();
 824         rt_cache_flush(0);
 825         arp_ifdown(dev);
 826 }
 827
 828 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
 829 {
 830         struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
 831
 832         switch (event) {
 833         case NETDEV_UP:
 834                 fib_add_ifaddr(ifa);
 835 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 836                 fib_sync_up(ifa->ifa_dev->dev);
 837 #endif
 838                 rt_cache_flush(-1);
 839                 break;
 840         case NETDEV_DOWN:
 841                 fib_del_ifaddr(ifa);
 842                 if (ifa->ifa_dev->ifa_list == NULL) {
 843                         /* Last address was deleted from this interface.
 844                            Disable IP.
 845                          */
 846                         fib_disable_ip(ifa->ifa_dev->dev, 1);
 847                 } else {
 848                         rt_cache_flush(-1);
 849                 }
 850                 break;
 851         }
 852         return NOTIFY_DONE;
 853 }
 854
 855 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 856 {
 857         struct net_device *dev = ptr;
 858         struct in_device *in_dev = __in_dev_get_rtnl(dev);
 859
 860         if (dev->nd_net != &init_net)
 861                 return NOTIFY_DONE;
 862
 863         if (event == NETDEV_UNREGISTER) {
 864                 fib_disable_ip(dev, 2);
 865                 return NOTIFY_DONE;
 866         }
 867
 868         if (!in_dev)
 869                 return NOTIFY_DONE;
 870
 871         switch (event) {
 872         case NETDEV_UP:
 873                 for_ifa(in_dev) {
 874                         fib_add_ifaddr(ifa);
 875                 } endfor_ifa(in_dev);
 876 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 877                 fib_sync_up(dev);
 878 #endif
 879                 rt_cache_flush(-1);
 880                 break;
 881         case NETDEV_DOWN:
 882                 fib_disable_ip(dev, 0);
 883                 break;
 884         case NETDEV_CHANGEMTU:
 885         case NETDEV_CHANGE:
 886                 rt_cache_flush(0);
 887                 break;
 888         }
 889         return NOTIFY_DONE;
 890 }
 891
 892 static struct notifier_block fib_inetaddr_notifier = {
 893         .notifier_call =fib_inetaddr_event,
 894 };
 895
 896 static struct notifier_block fib_netdev_notifier = {
 897         .notifier_call =fib_netdev_event,
 898 };
 899
 900 void __init ip_fib_init(void)
 901 {
 902         unsigned int i;
 903
 904         for (i = 0; i < FIB_TABLE_HASHSZ; i++)
 905                 INIT_HLIST_HEAD(&fib_table_hash[i]);
 906 #ifndef CONFIG_IP_MULTIPLE_TABLES
 907         ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
 908         hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
 909         ip_fib_main_table  = fib_hash_init(RT_TABLE_MAIN);
 910         hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
 911 #else
 912         fib4_rules_init();
 913 #endif
 914
 915         register_netdevice_notifier(&fib_netdev_notifier);
 916         register_inetaddr_notifier(&fib_inetaddr_notifier);
 917         nl_fib_lookup_init();
 918
 919         rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
 920         rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
 921         rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
 922 }
 923
 924 EXPORT_SYMBOL(inet_addr_type);
 925 EXPORT_SYMBOL(ip_dev_find);