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