git.oblomov.eu Git - linux-2.6/blob - net/ipv4/fib_frontend.c

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