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