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