SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ipv4/fib_frontend.c

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