net/ipv6/route.c

   1 /*
   2  *      Linux INET6 implementation
   3  *      FIB front-end.
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License
  10  *      as published by the Free Software Foundation; either version
  11  *      2 of the License, or (at your option) any later version.
  12  */
  13
  14 /*      Changes:
  15  *
  16  *      YOSHIFUJI Hideaki @USAGI
  17  *              reworked default router selection.
  18  *              - respect outgoing interface
  19  *              - select from (probably) reachable routers (i.e.
  20  *              routers in REACHABLE, STALE, DELAY or PROBE states).
  21  *              - always select the same router if it is (probably)
  22  *              reachable.  otherwise, round-robin the list.
  23  *      Ville Nuorvala
  24  *              Fixed routing subtrees.
  25  */
  26
  27 #define pr_fmt(fmt) "IPv6: " fmt
  28
  29 #include <linux/capability.h>
  30 #include <linux/errno.h>
  31 #include <linux/export.h>
  32 #include <linux/types.h>
  33 #include <linux/times.h>
  34 #include <linux/socket.h>
  35 #include <linux/sockios.h>
  36 #include <linux/net.h>
  37 #include <linux/route.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/in6.h>
  40 #include <linux/mroute6.h>
  41 #include <linux/init.h>
  42 #include <linux/if_arp.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #include <linux/nsproxy.h>
  46 #include <linux/slab.h>
  47 #include <net/net_namespace.h>
  48 #include <net/snmp.h>
  49 #include <net/ipv6.h>
  50 #include <net/ip6_fib.h>
  51 #include <net/ip6_route.h>
  52 #include <net/ndisc.h>
  53 #include <net/addrconf.h>
  54 #include <net/tcp.h>
  55 #include <linux/rtnetlink.h>
  56 #include <net/dst.h>
  57 #include <net/xfrm.h>
  58 #include <net/netevent.h>
  59 #include <net/netlink.h>
  60 #include <net/nexthop.h>
  61
  62 #include <asm/uaccess.h>
  63
  64 #ifdef CONFIG_SYSCTL
  65 #include <linux/sysctl.h>
  66 #endif
  67
  68 enum rt6_nud_state {
  69         RT6_NUD_FAIL_HARD = -2,
  70         RT6_NUD_FAIL_SOFT = -1,
  71         RT6_NUD_SUCCEED = 1
  72 };
  73
  74 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
  75                                     const struct in6_addr *dest);
  76 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
  77 static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
  78 static unsigned int      ip6_mtu(const struct dst_entry *dst);
  79 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  80 static void             ip6_dst_destroy(struct dst_entry *);
  81 static void             ip6_dst_ifdown(struct dst_entry *,
  82                                        struct net_device *dev, int how);
  83 static int               ip6_dst_gc(struct dst_ops *ops);
  84
  85 static int              ip6_pkt_discard(struct sk_buff *skb);
  86 static int              ip6_pkt_discard_out(struct sk_buff *skb);
  87 static int              ip6_pkt_prohibit(struct sk_buff *skb);
  88 static int              ip6_pkt_prohibit_out(struct sk_buff *skb);
  89 static void             ip6_link_failure(struct sk_buff *skb);
  90 static void             ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
  91                                            struct sk_buff *skb, u32 mtu);
  92 static void             rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
  93                                         struct sk_buff *skb);
  94
  95 #ifdef CONFIG_IPV6_ROUTE_INFO
  96 static struct rt6_info *rt6_add_route_info(struct net_device *dev,
  97                                            const struct in6_addr *prefix, int prefixlen,
  98                                            const struct in6_addr *gwaddr, unsigned int pref);
  99 static struct rt6_info *rt6_get_route_info(struct net_device *dev,
 100                                            const struct in6_addr *prefix, int prefixlen,
 101                                            const struct in6_addr *gwaddr);
 102 #endif
 103
 104 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
 105 {
 106         struct rt6_info *rt = (struct rt6_info *) dst;
 107         struct inet_peer *peer;
 108         u32 *p = NULL;
 109
 110         if (!(rt->dst.flags & DST_HOST))
 111                 return dst_cow_metrics_generic(dst, old);
 112
 113         peer = rt6_get_peer_create(rt);
 114         if (peer) {
 115                 u32 *old_p = __DST_METRICS_PTR(old);
 116                 unsigned long prev, new;
 117
 118                 p = peer->metrics;
 119                 if (inet_metrics_new(peer))
 120                         memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
 121
 122                 new = (unsigned long) p;
 123                 prev = cmpxchg(&dst->_metrics, old, new);
 124
 125                 if (prev != old) {
 126                         p = __DST_METRICS_PTR(prev);
 127                         if (prev & DST_METRICS_READ_ONLY)
 128                                 p = NULL;
 129                 }
 130         }
 131         return p;
 132 }
 133
 134 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
 135                                              struct sk_buff *skb,
 136                                              const void *daddr)
 137 {
 138         struct in6_addr *p = &rt->rt6i_gateway;
 139
 140         if (!ipv6_addr_any(p))
 141                 return (const void *) p;
 142         else if (skb)
 143                 return &ipv6_hdr(skb)->daddr;
 144         return daddr;
 145 }
 146
 147 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
 148                                           struct sk_buff *skb,
 149                                           const void *daddr)
 150 {
 151         struct rt6_info *rt = (struct rt6_info *) dst;
 152         struct neighbour *n;
 153
 154         daddr = choose_neigh_daddr(rt, skb, daddr);
 155         n = __ipv6_neigh_lookup(dst->dev, daddr);
 156         if (n)
 157                 return n;
 158         return neigh_create(&nd_tbl, daddr, dst->dev);
 159 }
 160
 161 static struct dst_ops ip6_dst_ops_template = {
 162         .family                 =       AF_INET6,
 163         .protocol               =       cpu_to_be16(ETH_P_IPV6),
 164         .gc                     =       ip6_dst_gc,
 165         .gc_thresh              =       1024,
 166         .check                  =       ip6_dst_check,
 167         .default_advmss         =       ip6_default_advmss,
 168         .mtu                    =       ip6_mtu,
 169         .cow_metrics            =       ipv6_cow_metrics,
 170         .destroy                =       ip6_dst_destroy,
 171         .ifdown                 =       ip6_dst_ifdown,
 172         .negative_advice        =       ip6_negative_advice,
 173         .link_failure           =       ip6_link_failure,
 174         .update_pmtu            =       ip6_rt_update_pmtu,
 175         .redirect               =       rt6_do_redirect,
 176         .local_out              =       __ip6_local_out,
 177         .neigh_lookup           =       ip6_neigh_lookup,
 178 };
 179
 180 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
 181 {
 182         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
 183
 184         return mtu ? : dst->dev->mtu;
 185 }
 186
 187 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
 188                                          struct sk_buff *skb, u32 mtu)
 189 {
 190 }
 191
 192 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
 193                                       struct sk_buff *skb)
 194 {
 195 }
 196
 197 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
 198                                          unsigned long old)
 199 {
 200         return NULL;
 201 }
 202
 203 static struct dst_ops ip6_dst_blackhole_ops = {
 204         .family                 =       AF_INET6,
 205         .protocol               =       cpu_to_be16(ETH_P_IPV6),
 206         .destroy                =       ip6_dst_destroy,
 207         .check                  =       ip6_dst_check,
 208         .mtu                    =       ip6_blackhole_mtu,
 209         .default_advmss         =       ip6_default_advmss,
 210         .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
 211         .redirect               =       ip6_rt_blackhole_redirect,
 212         .cow_metrics            =       ip6_rt_blackhole_cow_metrics,
 213         .neigh_lookup           =       ip6_neigh_lookup,
 214 };
 215
 216 static const u32 ip6_template_metrics[RTAX_MAX] = {
 217         [RTAX_HOPLIMIT - 1] = 0,
 218 };
 219
 220 static const struct rt6_info ip6_null_entry_template = {
 221         .dst = {
 222                 .__refcnt       = ATOMIC_INIT(1),
 223                 .__use          = 1,
 224                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 225                 .error          = -ENETUNREACH,
 226                 .input          = ip6_pkt_discard,
 227                 .output         = ip6_pkt_discard_out,
 228         },
 229         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 230         .rt6i_protocol  = RTPROT_KERNEL,
 231         .rt6i_metric    = ~(u32) 0,
 232         .rt6i_ref       = ATOMIC_INIT(1),
 233 };
 234
 235 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 236
 237 static const struct rt6_info ip6_prohibit_entry_template = {
 238         .dst = {
 239                 .__refcnt       = ATOMIC_INIT(1),
 240                 .__use          = 1,
 241                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 242                 .error          = -EACCES,
 243                 .input          = ip6_pkt_prohibit,
 244                 .output         = ip6_pkt_prohibit_out,
 245         },
 246         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 247         .rt6i_protocol  = RTPROT_KERNEL,
 248         .rt6i_metric    = ~(u32) 0,
 249         .rt6i_ref       = ATOMIC_INIT(1),
 250 };
 251
 252 static const struct rt6_info ip6_blk_hole_entry_template = {
 253         .dst = {
 254                 .__refcnt       = ATOMIC_INIT(1),
 255                 .__use          = 1,
 256                 .obsolete       = DST_OBSOLETE_FORCE_CHK,
 257                 .error          = -EINVAL,
 258                 .input          = dst_discard,
 259                 .output         = dst_discard,
 260         },
 261         .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
 262         .rt6i_protocol  = RTPROT_KERNEL,
 263         .rt6i_metric    = ~(u32) 0,
 264         .rt6i_ref       = ATOMIC_INIT(1),
 265 };
 266
 267 #endif
 268
 269 /* allocate dst with ip6_dst_ops */
 270 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
 271                                              struct net_device *dev,
 272                                              int flags,
 273                                              struct fib6_table *table)
 274 {
 275         struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
 276                                         0, DST_OBSOLETE_FORCE_CHK, flags);
 277
 278         if (rt) {
 279                 struct dst_entry *dst = &rt->dst;
 280
 281                 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
 282                 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
 283                 rt->rt6i_genid = rt_genid(net);
 284                 INIT_LIST_HEAD(&rt->rt6i_siblings);
 285                 rt->rt6i_nsiblings = 0;
 286         }
 287         return rt;
 288 }
 289
 290 static void ip6_dst_destroy(struct dst_entry *dst)
 291 {
 292         struct rt6_info *rt = (struct rt6_info *)dst;
 293         struct inet6_dev *idev = rt->rt6i_idev;
 294         struct dst_entry *from = dst->from;
 295
 296         if (!(rt->dst.flags & DST_HOST))
 297                 dst_destroy_metrics_generic(dst);
 298
 299         if (idev) {
 300                 rt->rt6i_idev = NULL;
 301                 in6_dev_put(idev);
 302         }
 303
 304         dst->from = NULL;
 305         dst_release(from);
 306
 307         if (rt6_has_peer(rt)) {
 308                 struct inet_peer *peer = rt6_peer_ptr(rt);
 309                 inet_putpeer(peer);
 310         }
 311 }
 312
 313 void rt6_bind_peer(struct rt6_info *rt, int create)
 314 {
 315         struct inet_peer_base *base;
 316         struct inet_peer *peer;
 317
 318         base = inetpeer_base_ptr(rt->_rt6i_peer);
 319         if (!base)
 320                 return;
 321
 322         peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
 323         if (peer) {
 324                 if (!rt6_set_peer(rt, peer))
 325                         inet_putpeer(peer);
 326         }
 327 }
 328
 329 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 330                            int how)
 331 {
 332         struct rt6_info *rt = (struct rt6_info *)dst;
 333         struct inet6_dev *idev = rt->rt6i_idev;
 334         struct net_device *loopback_dev =
 335                 dev_net(dev)->loopback_dev;
 336
 337         if (dev != loopback_dev) {
 338                 if (idev && idev->dev == dev) {
 339                         struct inet6_dev *loopback_idev =
 340                                 in6_dev_get(loopback_dev);
 341                         if (loopback_idev) {
 342                                 rt->rt6i_idev = loopback_idev;
 343                                 in6_dev_put(idev);
 344                         }
 345                 }
 346         }
 347 }
 348
 349 static bool rt6_check_expired(const struct rt6_info *rt)
 350 {
 351         if (rt->rt6i_flags & RTF_EXPIRES) {
 352                 if (time_after(jiffies, rt->dst.expires))
 353                         return true;
 354         } else if (rt->dst.from) {
 355                 return rt6_check_expired((struct rt6_info *) rt->dst.from);
 356         }
 357         return false;
 358 }
 359
 360 static bool rt6_need_strict(const struct in6_addr *daddr)
 361 {
 362         return ipv6_addr_type(daddr) &
 363                 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
 364 }
 365
 366 /* Multipath route selection:
 367  *   Hash based function using packet header and flowlabel.
 368  * Adapted from fib_info_hashfn()
 369  */
 370 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
 371                                const struct flowi6 *fl6)
 372 {
 373         unsigned int val = fl6->flowi6_proto;
 374
 375         val ^= ipv6_addr_hash(&fl6->daddr);
 376         val ^= ipv6_addr_hash(&fl6->saddr);
 377
 378         /* Work only if this not encapsulated */
 379         switch (fl6->flowi6_proto) {
 380         case IPPROTO_UDP:
 381         case IPPROTO_TCP:
 382         case IPPROTO_SCTP:
 383                 val ^= (__force u16)fl6->fl6_sport;
 384                 val ^= (__force u16)fl6->fl6_dport;
 385                 break;
 386
 387         case IPPROTO_ICMPV6:
 388                 val ^= (__force u16)fl6->fl6_icmp_type;
 389                 val ^= (__force u16)fl6->fl6_icmp_code;
 390                 break;
 391         }
 392         /* RFC6438 recommands to use flowlabel */
 393         val ^= (__force u32)fl6->flowlabel;
 394
 395         /* Perhaps, we need to tune, this function? */
 396         val = val ^ (val >> 7) ^ (val >> 12);
 397         return val % candidate_count;
 398 }
 399
 400 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
 401                                              struct flowi6 *fl6)
 402 {
 403         struct rt6_info *sibling, *next_sibling;
 404         int route_choosen;
 405
 406         route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
 407         /* Don't change the route, if route_choosen == 0
 408          * (siblings does not include ourself)
 409          */
 410         if (route_choosen)
 411                 list_for_each_entry_safe(sibling, next_sibling,
 412                                 &match->rt6i_siblings, rt6i_siblings) {
 413                         route_choosen--;
 414                         if (route_choosen == 0) {
 415                                 match = sibling;
 416                                 break;
 417                         }
 418                 }
 419         return match;
 420 }
 421
 422 /*
 423  *      Route lookup. Any table->tb6_lock is implied.
 424  */
 425
 426 static inline struct rt6_info *rt6_device_match(struct net *net,
 427                                                     struct rt6_info *rt,
 428                                                     const struct in6_addr *saddr,
 429                                                     int oif,
 430                                                     int flags)
 431 {
 432         struct rt6_info *local = NULL;
 433         struct rt6_info *sprt;
 434
 435         if (!oif && ipv6_addr_any(saddr))
 436                 goto out;
 437
 438         for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
 439                 struct net_device *dev = sprt->dst.dev;
 440
 441                 if (oif) {
 442                         if (dev->ifindex == oif)
 443                                 return sprt;
 444                         if (dev->flags & IFF_LOOPBACK) {
 445                                 if (!sprt->rt6i_idev ||
 446                                     sprt->rt6i_idev->dev->ifindex != oif) {
 447                                         if (flags & RT6_LOOKUP_F_IFACE && oif)
 448                                                 continue;
 449                                         if (local && (!oif ||
 450                                                       local->rt6i_idev->dev->ifindex == oif))
 451                                                 continue;
 452                                 }
 453                                 local = sprt;
 454                         }
 455                 } else {
 456                         if (ipv6_chk_addr(net, saddr, dev,
 457                                           flags & RT6_LOOKUP_F_IFACE))
 458                                 return sprt;
 459                 }
 460         }
 461
 462         if (oif) {
 463                 if (local)
 464                         return local;
 465
 466                 if (flags & RT6_LOOKUP_F_IFACE)
 467                         return net->ipv6.ip6_null_entry;
 468         }
 469 out:
 470         return rt;
 471 }
 472
 473 #ifdef CONFIG_IPV6_ROUTER_PREF
 474 struct __rt6_probe_work {
 475         struct work_struct work;
 476         struct in6_addr target;
 477         struct net_device *dev;
 478 };
 479
 480 static void rt6_probe_deferred(struct work_struct *w)
 481 {
 482         struct in6_addr mcaddr;
 483         struct __rt6_probe_work *work =
 484                 container_of(w, struct __rt6_probe_work, work);
 485
 486         addrconf_addr_solict_mult(&work->target, &mcaddr);
 487         ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
 488         dev_put(work->dev);
 489         kfree(w);
 490 }
 491
 492 static void rt6_probe(struct rt6_info *rt)
 493 {
 494         struct neighbour *neigh;
 495         /*
 496          * Okay, this does not seem to be appropriate
 497          * for now, however, we need to check if it
 498          * is really so; aka Router Reachability Probing.
 499          *
 500          * Router Reachability Probe MUST be rate-limited
 501          * to no more than one per minute.
 502          */
 503         if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
 504                 return;
 505         rcu_read_lock_bh();
 506         neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
 507         if (neigh) {
 508                 write_lock(&neigh->lock);
 509                 if (neigh->nud_state & NUD_VALID)
 510                         goto out;
 511         }
 512
 513         if (!neigh ||
 514             time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
 515                 struct __rt6_probe_work *work;
 516
 517                 work = kmalloc(sizeof(*work), GFP_ATOMIC);
 518
 519                 if (neigh && work)
 520                         neigh->updated = jiffies;
 521
 522                 if (neigh)
 523                         write_unlock(&neigh->lock);
 524
 525                 if (work) {
 526                         INIT_WORK(&work->work, rt6_probe_deferred);
 527                         work->target = rt->rt6i_gateway;
 528                         dev_hold(rt->dst.dev);
 529                         work->dev = rt->dst.dev;
 530                         schedule_work(&work->work);
 531                 }
 532         } else {
 533 out:
 534                 write_unlock(&neigh->lock);
 535         }
 536         rcu_read_unlock_bh();
 537 }
 538 #else
 539 static inline void rt6_probe(struct rt6_info *rt)
 540 {
 541 }
 542 #endif
 543
 544 /*
 545  * Default Router Selection (RFC 2461 6.3.6)
 546  */
 547 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
 548 {
 549         struct net_device *dev = rt->dst.dev;
 550         if (!oif || dev->ifindex == oif)
 551                 return 2;
 552         if ((dev->flags & IFF_LOOPBACK) &&
 553             rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
 554                 return 1;
 555         return 0;
 556 }
 557
 558 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
 559 {
 560         struct neighbour *neigh;
 561         enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
 562
 563         if (rt->rt6i_flags & RTF_NONEXTHOP ||
 564             !(rt->rt6i_flags & RTF_GATEWAY))
 565                 return RT6_NUD_SUCCEED;
 566
 567         rcu_read_lock_bh();
 568         neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
 569         if (neigh) {
 570                 read_lock(&neigh->lock);
 571                 if (neigh->nud_state & NUD_VALID)
 572                         ret = RT6_NUD_SUCCEED;
 573 #ifdef CONFIG_IPV6_ROUTER_PREF
 574                 else if (!(neigh->nud_state & NUD_FAILED))
 575                         ret = RT6_NUD_SUCCEED;
 576 #endif
 577                 read_unlock(&neigh->lock);
 578         } else {
 579                 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
 580                       RT6_NUD_SUCCEED : RT6_NUD_FAIL_SOFT;
 581         }
 582         rcu_read_unlock_bh();
 583
 584         return ret;
 585 }
 586
 587 static int rt6_score_route(struct rt6_info *rt, int oif,
 588                            int strict)
 589 {
 590         int m;
 591
 592         m = rt6_check_dev(rt, oif);
 593         if (!m && (strict & RT6_LOOKUP_F_IFACE))
 594                 return RT6_NUD_FAIL_HARD;
 595 #ifdef CONFIG_IPV6_ROUTER_PREF
 596         m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 597 #endif
 598         if (strict & RT6_LOOKUP_F_REACHABLE) {
 599                 int n = rt6_check_neigh(rt);
 600                 if (n < 0)
 601                         return n;
 602         }
 603         return m;
 604 }
 605
 606 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
 607                                    int *mpri, struct rt6_info *match,
 608                                    bool *do_rr)
 609 {
 610         int m;
 611         bool match_do_rr = false;
 612
 613         if (rt6_check_expired(rt))
 614                 goto out;
 615
 616         m = rt6_score_route(rt, oif, strict);
 617         if (m == RT6_NUD_FAIL_SOFT && !IS_ENABLED(CONFIG_IPV6_ROUTER_PREF)) {
 618                 match_do_rr = true;
 619                 m = 0; /* lowest valid score */
 620         } else if (m < 0) {
 621                 goto out;
 622         }
 623
 624         if (strict & RT6_LOOKUP_F_REACHABLE)
 625                 rt6_probe(rt);
 626
 627         if (m > *mpri) {
 628                 *do_rr = match_do_rr;
 629                 *mpri = m;
 630                 match = rt;
 631         }
 632 out:
 633         return match;
 634 }
 635
 636 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
 637                                      struct rt6_info *rr_head,
 638                                      u32 metric, int oif, int strict,
 639                                      bool *do_rr)
 640 {
 641         struct rt6_info *rt, *match;
 642         int mpri = -1;
 643
 644         match = NULL;
 645         for (rt = rr_head; rt && rt->rt6i_metric == metric;
 646              rt = rt->dst.rt6_next)
 647                 match = find_match(rt, oif, strict, &mpri, match, do_rr);
 648         for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
 649              rt = rt->dst.rt6_next)
 650                 match = find_match(rt, oif, strict, &mpri, match, do_rr);
 651
 652         return match;
 653 }
 654
 655 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 656 {
 657         struct rt6_info *match, *rt0;
 658         struct net *net;
 659         bool do_rr = false;
 660
 661         rt0 = fn->rr_ptr;
 662         if (!rt0)
 663                 fn->rr_ptr = rt0 = fn->leaf;
 664
 665         match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
 666                              &do_rr);
 667
 668         if (do_rr) {
 669                 struct rt6_info *next = rt0->dst.rt6_next;
 670
 671                 /* no entries matched; do round-robin */
 672                 if (!next || next->rt6i_metric != rt0->rt6i_metric)
 673                         next = fn->leaf;
 674
 675                 if (next != rt0)
 676                         fn->rr_ptr = next;
 677         }
 678
 679         net = dev_net(rt0->dst.dev);
 680         return match ? match : net->ipv6.ip6_null_entry;
 681 }
 682
 683 #ifdef CONFIG_IPV6_ROUTE_INFO
 684 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 685                   const struct in6_addr *gwaddr)
 686 {
 687         struct route_info *rinfo = (struct route_info *) opt;
 688         struct in6_addr prefix_buf, *prefix;
 689         unsigned int pref;
 690         unsigned long lifetime;
 691         struct rt6_info *rt;
 692
 693         if (len < sizeof(struct route_info)) {
 694                 return -EINVAL;
 695         }
 696
 697         /* Sanity check for prefix_len and length */
 698         if (rinfo->length > 3) {
 699                 return -EINVAL;
 700         } else if (rinfo->prefix_len > 128) {
 701                 return -EINVAL;
 702         } else if (rinfo->prefix_len > 64) {
 703                 if (rinfo->length < 2) {
 704                         return -EINVAL;
 705                 }
 706         } else if (rinfo->prefix_len > 0) {
 707                 if (rinfo->length < 1) {
 708                         return -EINVAL;
 709                 }
 710         }
 711
 712         pref = rinfo->route_pref;
 713         if (pref == ICMPV6_ROUTER_PREF_INVALID)
 714                 return -EINVAL;
 715
 716         lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 717
 718         if (rinfo->length == 3)
 719                 prefix = (struct in6_addr *)rinfo->prefix;
 720         else {
 721                 /* this function is safe */
 722                 ipv6_addr_prefix(&prefix_buf,
 723                                  (struct in6_addr *)rinfo->prefix,
 724                                  rinfo->prefix_len);
 725                 prefix = &prefix_buf;
 726         }
 727
 728         if (rinfo->prefix_len == 0)
 729                 rt = rt6_get_dflt_router(gwaddr, dev);
 730         else
 731                 rt = rt6_get_route_info(dev, prefix, rinfo->prefix_len, gwaddr);
 732
 733         if (rt && !lifetime) {
 734                 ip6_del_rt(rt);
 735                 rt = NULL;
 736         }
 737
 738         if (!rt && lifetime)
 739                 rt = rt6_add_route_info(dev, prefix, rinfo->prefix_len, gwaddr, pref);
 740         else if (rt)
 741                 rt->rt6i_flags = RTF_ROUTEINFO |
 742                                  (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 743
 744         if (rt) {
 745                 if (!addrconf_finite_timeout(lifetime))
 746                         rt6_clean_expires(rt);
 747                 else
 748                         rt6_set_expires(rt, jiffies + HZ * lifetime);
 749
 750                 ip6_rt_put(rt);
 751         }
 752         return 0;
 753 }
 754 #endif
 755
 756 #define BACKTRACK(__net, saddr)                 \
 757 do { \
 758         if (rt == __net->ipv6.ip6_null_entry) { \
 759                 struct fib6_node *pn; \
 760                 while (1) { \
 761                         if (fn->fn_flags & RTN_TL_ROOT) \
 762                                 goto out; \
 763                         pn = fn->parent; \
 764                         if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
 765                                 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
 766                         else \
 767                                 fn = pn; \
 768                         if (fn->fn_flags & RTN_RTINFO) \
 769                                 goto restart; \
 770                 } \
 771         } \
 772 } while (0)
 773
 774 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
 775                                              struct fib6_table *table,
 776                                              struct flowi6 *fl6, int flags)
 777 {
 778         struct fib6_node *fn;
 779         struct rt6_info *rt;
 780
 781         read_lock_bh(&table->tb6_lock);
 782         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
 783 restart:
 784         rt = fn->leaf;
 785         rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
 786         if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
 787                 rt = rt6_multipath_select(rt, fl6);
 788         BACKTRACK(net, &fl6->saddr);
 789 out:
 790         dst_use(&rt->dst, jiffies);
 791         read_unlock_bh(&table->tb6_lock);
 792         return rt;
 793
 794 }
 795
 796 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
 797                                     int flags)
 798 {
 799         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
 800 }
 801 EXPORT_SYMBOL_GPL(ip6_route_lookup);
 802
 803 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
 804                             const struct in6_addr *saddr, int oif, int strict)
 805 {
 806         struct flowi6 fl6 = {
 807                 .flowi6_oif = oif,
 808                 .daddr = *daddr,
 809         };
 810         struct dst_entry *dst;
 811         int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
 812
 813         if (saddr) {
 814                 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
 815                 flags |= RT6_LOOKUP_F_HAS_SADDR;
 816         }
 817
 818         dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
 819         if (dst->error == 0)
 820                 return (struct rt6_info *) dst;
 821
 822         dst_release(dst);
 823
 824         return NULL;
 825 }
 826
 827 EXPORT_SYMBOL(rt6_lookup);
 828
 829 /* ip6_ins_rt is called with FREE table->tb6_lock.
 830    It takes new route entry, the addition fails by any reason the
 831    route is freed. In any case, if caller does not hold it, it may
 832    be destroyed.
 833  */
 834
 835 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
 836 {
 837         int err;
 838         struct fib6_table *table;
 839
 840         table = rt->rt6i_table;
 841         write_lock_bh(&table->tb6_lock);
 842         err = fib6_add(&table->tb6_root, rt, info);
 843         write_unlock_bh(&table->tb6_lock);
 844
 845         return err;
 846 }
 847
 848 int ip6_ins_rt(struct rt6_info *rt)
 849 {
 850         struct nl_info info = {
 851                 .nl_net = dev_net(rt->dst.dev),
 852         };
 853         return __ip6_ins_rt(rt, &info);
 854 }
 855
 856 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
 857                                       const struct in6_addr *daddr,
 858                                       const struct in6_addr *saddr)
 859 {
 860         struct rt6_info *rt;
 861
 862         /*
 863          *      Clone the route.
 864          */
 865
 866         rt = ip6_rt_copy(ort, daddr);
 867
 868         if (rt) {
 869                 if (!(rt->rt6i_flags & RTF_GATEWAY)) {
 870                         if (ort->rt6i_dst.plen != 128 &&
 871                             ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
 872                                 rt->rt6i_flags |= RTF_ANYCAST;
 873                 }
 874
 875                 rt->rt6i_flags |= RTF_CACHE;
 876
 877 #ifdef CONFIG_IPV6_SUBTREES
 878                 if (rt->rt6i_src.plen && saddr) {
 879                         rt->rt6i_src.addr = *saddr;
 880                         rt->rt6i_src.plen = 128;
 881                 }
 882 #endif
 883         }
 884
 885         return rt;
 886 }
 887
 888 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
 889                                         const struct in6_addr *daddr)
 890 {
 891         struct rt6_info *rt = ip6_rt_copy(ort, daddr);
 892
 893         if (rt)
 894                 rt->rt6i_flags |= RTF_CACHE;
 895         return rt;
 896 }
 897
 898 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
 899                                       struct flowi6 *fl6, int flags)
 900 {
 901         struct fib6_node *fn;
 902         struct rt6_info *rt, *nrt;
 903         int strict = 0;
 904         int attempts = 3;
 905         int err;
 906         int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 907
 908         strict |= flags & RT6_LOOKUP_F_IFACE;
 909
 910 relookup:
 911         read_lock_bh(&table->tb6_lock);
 912
 913 restart_2:
 914         fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
 915
 916 restart:
 917         rt = rt6_select(fn, oif, strict | reachable);
 918         if (rt->rt6i_nsiblings && oif == 0)
 919                 rt = rt6_multipath_select(rt, fl6);
 920         BACKTRACK(net, &fl6->saddr);
 921         if (rt == net->ipv6.ip6_null_entry ||
 922             rt->rt6i_flags & RTF_CACHE)
 923                 goto out;
 924
 925         dst_hold(&rt->dst);
 926         read_unlock_bh(&table->tb6_lock);
 927
 928         if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
 929                 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
 930         else if (!(rt->dst.flags & DST_HOST))
 931                 nrt = rt6_alloc_clone(rt, &fl6->daddr);
 932         else
 933                 goto out2;
 934
 935         ip6_rt_put(rt);
 936         rt = nrt ? : net->ipv6.ip6_null_entry;
 937
 938         dst_hold(&rt->dst);
 939         if (nrt) {
 940                 err = ip6_ins_rt(nrt);
 941                 if (!err)
 942                         goto out2;
 943         }
 944
 945         if (--attempts <= 0)
 946                 goto out2;
 947
 948         /*
 949          * Race condition! In the gap, when table->tb6_lock was
 950          * released someone could insert this route.  Relookup.
 951          */
 952         ip6_rt_put(rt);
 953         goto relookup;
 954
 955 out:
 956         if (reachable) {
 957                 reachable = 0;
 958                 goto restart_2;
 959         }
 960         dst_hold(&rt->dst);
 961         read_unlock_bh(&table->tb6_lock);
 962 out2:
 963         rt->dst.lastuse = jiffies;
 964         rt->dst.__use++;
 965
 966         return rt;
 967 }
 968
 969 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
 970                                             struct flowi6 *fl6, int flags)
 971 {
 972         return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
 973 }
 974
 975 static struct dst_entry *ip6_route_input_lookup(struct net *net,
 976                                                 struct net_device *dev,
 977                                                 struct flowi6 *fl6, int flags)
 978 {
 979         if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
 980                 flags |= RT6_LOOKUP_F_IFACE;
 981
 982         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
 983 }
 984
 985 void ip6_route_input(struct sk_buff *skb)
 986 {
 987         const struct ipv6hdr *iph = ipv6_hdr(skb);
 988         struct net *net = dev_net(skb->dev);
 989         int flags = RT6_LOOKUP_F_HAS_SADDR;
 990         struct flowi6 fl6 = {
 991                 .flowi6_iif = skb->dev->ifindex,
 992                 .daddr = iph->daddr,
 993                 .saddr = iph->saddr,
 994                 .flowlabel = ip6_flowinfo(iph),
 995                 .flowi6_mark = skb->mark,
 996                 .flowi6_proto = iph->nexthdr,
 997         };
 998
 999         skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1000 }
1001
1002 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1003                                              struct flowi6 *fl6, int flags)
1004 {
1005         return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1006 }
1007
1008 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
1009                                     struct flowi6 *fl6)
1010 {
1011         int flags = 0;
1012
1013         fl6->flowi6_iif = LOOPBACK_IFINDEX;
1014
1015         if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1016                 flags |= RT6_LOOKUP_F_IFACE;
1017
1018         if (!ipv6_addr_any(&fl6->saddr))
1019                 flags |= RT6_LOOKUP_F_HAS_SADDR;
1020         else if (sk)
1021                 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1022
1023         return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1024 }
1025
1026 EXPORT_SYMBOL(ip6_route_output);
1027
1028 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1029 {
1030         struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1031         struct dst_entry *new = NULL;
1032
1033         rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1034         if (rt) {
1035                 new = &rt->dst;
1036
1037                 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1038                 rt6_init_peer(rt, net->ipv6.peers);
1039
1040                 new->__use = 1;
1041                 new->input = dst_discard;
1042                 new->output = dst_discard;
1043
1044                 if (dst_metrics_read_only(&ort->dst))
1045                         new->_metrics = ort->dst._metrics;
1046                 else
1047                         dst_copy_metrics(new, &ort->dst);
1048                 rt->rt6i_idev = ort->rt6i_idev;
1049                 if (rt->rt6i_idev)
1050                         in6_dev_hold(rt->rt6i_idev);
1051
1052                 rt->rt6i_gateway = ort->rt6i_gateway;
1053                 rt->rt6i_flags = ort->rt6i_flags;
1054                 rt->rt6i_metric = 0;
1055
1056                 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1057 #ifdef CONFIG_IPV6_SUBTREES
1058                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1059 #endif
1060
1061                 dst_free(new);
1062         }
1063
1064         dst_release(dst_orig);
1065         return new ? new : ERR_PTR(-ENOMEM);
1066 }
1067
1068 /*
1069  *      Destination cache support functions
1070  */
1071
1072 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1073 {
1074         struct rt6_info *rt;
1075
1076         rt = (struct rt6_info *) dst;
1077
1078         /* All IPV6 dsts are created with ->obsolete set to the value
1079          * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1080          * into this function always.
1081          */
1082         if (rt->rt6i_genid != rt_genid(dev_net(rt->dst.dev)))
1083                 return NULL;
1084
1085         if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1086                 return NULL;
1087
1088         if (rt6_check_expired(rt))
1089                 return NULL;
1090
1091         return dst;
1092 }
1093
1094 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1095 {
1096         struct rt6_info *rt = (struct rt6_info *) dst;
1097
1098         if (rt) {
1099                 if (rt->rt6i_flags & RTF_CACHE) {
1100                         if (rt6_check_expired(rt)) {
1101                                 ip6_del_rt(rt);
1102                                 dst = NULL;
1103                         }
1104                 } else {
1105                         dst_release(dst);
1106                         dst = NULL;
1107                 }
1108         }
1109         return dst;
1110 }
1111
1112 static void ip6_link_failure(struct sk_buff *skb)
1113 {
1114         struct rt6_info *rt;
1115
1116         icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1117
1118         rt = (struct rt6_info *) skb_dst(skb);
1119         if (rt) {
1120                 if (rt->rt6i_flags & RTF_CACHE) {
1121                         dst_hold(&rt->dst);
1122                         if (ip6_del_rt(rt))
1123                                 dst_free(&rt->dst);
1124                 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1125                         rt->rt6i_node->fn_sernum = -1;
1126                 }
1127         }
1128 }
1129
1130 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1131                                struct sk_buff *skb, u32 mtu)
1132 {
1133         struct rt6_info *rt6 = (struct rt6_info*)dst;
1134
1135         dst_confirm(dst);
1136         if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1137                 struct net *net = dev_net(dst->dev);
1138
1139                 rt6->rt6i_flags |= RTF_MODIFIED;
1140                 if (mtu < IPV6_MIN_MTU)
1141                         mtu = IPV6_MIN_MTU;
1142
1143                 dst_metric_set(dst, RTAX_MTU, mtu);
1144                 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1145         }
1146 }
1147
1148 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1149                      int oif, u32 mark, kuid_t uid)
1150 {
1151         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1152         struct dst_entry *dst;
1153         struct flowi6 fl6;
1154
1155         memset(&fl6, 0, sizeof(fl6));
1156         fl6.flowi6_oif = oif;
1157         fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1158         fl6.flowi6_flags = 0;
1159         fl6.daddr = iph->daddr;
1160         fl6.saddr = iph->saddr;
1161         fl6.flowlabel = ip6_flowinfo(iph);
1162         fl6.flowi6_uid = uid;
1163
1164         dst = ip6_route_output(net, NULL, &fl6);
1165         if (!dst->error)
1166                 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1167         dst_release(dst);
1168 }
1169 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1170
1171 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1172 {
1173         ip6_update_pmtu(skb, sock_net(sk), mtu,
1174                         sk->sk_bound_dev_if, sk->sk_mark, sock_i_uid(sk));
1175 }
1176 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1177
1178 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1179 {
1180         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1181         struct dst_entry *dst;
1182         struct flowi6 fl6;
1183
1184         memset(&fl6, 0, sizeof(fl6));
1185         fl6.flowi6_oif = oif;
1186         fl6.flowi6_mark = mark;
1187         fl6.flowi6_flags = 0;
1188         fl6.daddr = iph->daddr;
1189         fl6.saddr = iph->saddr;
1190         fl6.flowlabel = ip6_flowinfo(iph);
1191
1192         dst = ip6_route_output(net, NULL, &fl6);
1193         if (!dst->error)
1194                 rt6_do_redirect(dst, NULL, skb);
1195         dst_release(dst);
1196 }
1197 EXPORT_SYMBOL_GPL(ip6_redirect);
1198
1199 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1200 {
1201         ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1202 }
1203 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1204
1205 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1206 {
1207         struct net_device *dev = dst->dev;
1208         unsigned int mtu = dst_mtu(dst);
1209         struct net *net = dev_net(dev);
1210
1211         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1212
1213         if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1214                 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1215
1216         /*
1217          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1218          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1219          * IPV6_MAXPLEN is also valid and means: "any MSS,
1220          * rely only on pmtu discovery"
1221          */
1222         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1223                 mtu = IPV6_MAXPLEN;
1224         return mtu;
1225 }
1226
1227 static unsigned int ip6_mtu(const struct dst_entry *dst)
1228 {
1229         struct inet6_dev *idev;
1230         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1231
1232         if (mtu)
1233                 goto out;
1234
1235         mtu = IPV6_MIN_MTU;
1236
1237         rcu_read_lock();
1238         idev = __in6_dev_get(dst->dev);
1239         if (idev)
1240                 mtu = idev->cnf.mtu6;
1241         rcu_read_unlock();
1242
1243 out:
1244         return min_t(unsigned int, mtu, IP6_MAX_MTU);
1245 }
1246
1247 static struct dst_entry *icmp6_dst_gc_list;
1248 static DEFINE_SPINLOCK(icmp6_dst_lock);
1249
1250 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1251                                   struct flowi6 *fl6)
1252 {
1253         struct dst_entry *dst;
1254         struct rt6_info *rt;
1255         struct inet6_dev *idev = in6_dev_get(dev);
1256         struct net *net = dev_net(dev);
1257
1258         if (unlikely(!idev))
1259                 return ERR_PTR(-ENODEV);
1260
1261         rt = ip6_dst_alloc(net, dev, 0, NULL);
1262         if (unlikely(!rt)) {
1263                 in6_dev_put(idev);
1264                 dst = ERR_PTR(-ENOMEM);
1265                 goto out;
1266         }
1267
1268         rt->dst.flags |= DST_HOST;
1269         rt->dst.output  = ip6_output;
1270         atomic_set(&rt->dst.__refcnt, 1);
1271         rt->rt6i_gateway  = fl6->daddr;
1272         rt->rt6i_dst.addr = fl6->daddr;
1273         rt->rt6i_dst.plen = 128;
1274         rt->rt6i_idev     = idev;
1275         dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1276
1277         spin_lock_bh(&icmp6_dst_lock);
1278         rt->dst.next = icmp6_dst_gc_list;
1279         icmp6_dst_gc_list = &rt->dst;
1280         spin_unlock_bh(&icmp6_dst_lock);
1281
1282         fib6_force_start_gc(net);
1283
1284         dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1285
1286 out:
1287         return dst;
1288 }
1289
1290 int icmp6_dst_gc(void)
1291 {
1292         struct dst_entry *dst, **pprev;
1293         int more = 0;
1294
1295         spin_lock_bh(&icmp6_dst_lock);
1296         pprev = &icmp6_dst_gc_list;
1297
1298         while ((dst = *pprev) != NULL) {
1299                 if (!atomic_read(&dst->__refcnt)) {
1300                         *pprev = dst->next;
1301                         dst_free(dst);
1302                 } else {
1303                         pprev = &dst->next;
1304                         ++more;
1305                 }
1306         }
1307
1308         spin_unlock_bh(&icmp6_dst_lock);
1309
1310         return more;
1311 }
1312
1313 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1314                             void *arg)
1315 {
1316         struct dst_entry *dst, **pprev;
1317
1318         spin_lock_bh(&icmp6_dst_lock);
1319         pprev = &icmp6_dst_gc_list;
1320         while ((dst = *pprev) != NULL) {
1321                 struct rt6_info *rt = (struct rt6_info *) dst;
1322                 if (func(rt, arg)) {
1323                         *pprev = dst->next;
1324                         dst_free(dst);
1325                 } else {
1326                         pprev = &dst->next;
1327                 }
1328         }
1329         spin_unlock_bh(&icmp6_dst_lock);
1330 }
1331
1332 static int ip6_dst_gc(struct dst_ops *ops)
1333 {
1334         struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1335         int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1336         int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1337         int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1338         int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1339         unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1340         int entries;
1341
1342         entries = dst_entries_get_fast(ops);
1343         if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1344             entries <= rt_max_size)
1345                 goto out;
1346
1347         net->ipv6.ip6_rt_gc_expire++;
1348         fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, entries > rt_max_size);
1349         entries = dst_entries_get_slow(ops);
1350         if (entries < ops->gc_thresh)
1351                 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1352 out:
1353         net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1354         return entries > rt_max_size;
1355 }
1356
1357 int ip6_dst_hoplimit(struct dst_entry *dst)
1358 {
1359         int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1360         if (hoplimit == 0) {
1361                 struct net_device *dev = dst->dev;
1362                 struct inet6_dev *idev;
1363
1364                 rcu_read_lock();
1365                 idev = __in6_dev_get(dev);
1366                 if (idev)
1367                         hoplimit = idev->cnf.hop_limit;
1368                 else
1369                         hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1370                 rcu_read_unlock();
1371         }
1372         return hoplimit;
1373 }
1374 EXPORT_SYMBOL(ip6_dst_hoplimit);
1375
1376 /*
1377  *
1378  */
1379
1380 int ip6_route_add(struct fib6_config *cfg)
1381 {
1382         int err;
1383         struct net *net = cfg->fc_nlinfo.nl_net;
1384         struct rt6_info *rt = NULL;
1385         struct net_device *dev = NULL;
1386         struct inet6_dev *idev = NULL;
1387         struct fib6_table *table;
1388         int addr_type;
1389
1390         if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1391                 return -EINVAL;
1392 #ifndef CONFIG_IPV6_SUBTREES
1393         if (cfg->fc_src_len)
1394                 return -EINVAL;
1395 #endif
1396         if (cfg->fc_ifindex) {
1397                 err = -ENODEV;
1398                 dev = dev_get_by_index(net, cfg->fc_ifindex);
1399                 if (!dev)
1400                         goto out;
1401                 idev = in6_dev_get(dev);
1402                 if (!idev)
1403                         goto out;
1404         }
1405
1406         if (cfg->fc_metric == 0)
1407                 cfg->fc_metric = IP6_RT_PRIO_USER;
1408
1409         err = -ENOBUFS;
1410         if (cfg->fc_nlinfo.nlh &&
1411             !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1412                 table = fib6_get_table(net, cfg->fc_table);
1413                 if (!table) {
1414                         pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1415                         table = fib6_new_table(net, cfg->fc_table);
1416                 }
1417         } else {
1418                 table = fib6_new_table(net, cfg->fc_table);
1419         }
1420
1421         if (!table)
1422                 goto out;
1423
1424         rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1425
1426         if (!rt) {
1427                 err = -ENOMEM;
1428                 goto out;
1429         }
1430
1431         if (cfg->fc_flags & RTF_EXPIRES)
1432                 rt6_set_expires(rt, jiffies +
1433                                 clock_t_to_jiffies(cfg->fc_expires));
1434         else
1435                 rt6_clean_expires(rt);
1436
1437         if (cfg->fc_protocol == RTPROT_UNSPEC)
1438                 cfg->fc_protocol = RTPROT_BOOT;
1439         rt->rt6i_protocol = cfg->fc_protocol;
1440
1441         addr_type = ipv6_addr_type(&cfg->fc_dst);
1442
1443         if (addr_type & IPV6_ADDR_MULTICAST)
1444                 rt->dst.input = ip6_mc_input;
1445         else if (cfg->fc_flags & RTF_LOCAL)
1446                 rt->dst.input = ip6_input;
1447         else
1448                 rt->dst.input = ip6_forward;
1449
1450         rt->dst.output = ip6_output;
1451
1452         ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1453         rt->rt6i_dst.plen = cfg->fc_dst_len;
1454         if (rt->rt6i_dst.plen == 128)
1455                rt->dst.flags |= DST_HOST;
1456
1457         if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1458                 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1459                 if (!metrics) {
1460                         err = -ENOMEM;
1461                         goto out;
1462                 }
1463                 dst_init_metrics(&rt->dst, metrics, 0);
1464         }
1465 #ifdef CONFIG_IPV6_SUBTREES
1466         ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1467         rt->rt6i_src.plen = cfg->fc_src_len;
1468 #endif
1469
1470         rt->rt6i_metric = cfg->fc_metric;
1471
1472         /* We cannot add true routes via loopback here,
1473            they would result in kernel looping; promote them to reject routes
1474          */
1475         if ((cfg->fc_flags & RTF_REJECT) ||
1476             (dev && (dev->flags & IFF_LOOPBACK) &&
1477              !(addr_type & IPV6_ADDR_LOOPBACK) &&
1478              !(cfg->fc_flags & RTF_LOCAL))) {
1479                 /* hold loopback dev/idev if we haven't done so. */
1480                 if (dev != net->loopback_dev) {
1481                         if (dev) {
1482                                 dev_put(dev);
1483                                 in6_dev_put(idev);
1484                         }
1485                         dev = net->loopback_dev;
1486                         dev_hold(dev);
1487                         idev = in6_dev_get(dev);
1488                         if (!idev) {
1489                                 err = -ENODEV;
1490                                 goto out;
1491                         }
1492                 }
1493                 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1494                 switch (cfg->fc_type) {
1495                 case RTN_BLACKHOLE:
1496                         rt->dst.error = -EINVAL;
1497                         rt->dst.output = dst_discard;
1498                         rt->dst.input = dst_discard;
1499                         break;
1500                 case RTN_PROHIBIT:
1501                         rt->dst.error = -EACCES;
1502                         rt->dst.output = ip6_pkt_prohibit_out;
1503                         rt->dst.input = ip6_pkt_prohibit;
1504                         break;
1505                 case RTN_THROW:
1506                 default:
1507                         rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1508                                         : -ENETUNREACH;
1509                         rt->dst.output = ip6_pkt_discard_out;
1510                         rt->dst.input = ip6_pkt_discard;
1511                         break;
1512                 }
1513                 goto install_route;
1514         }
1515
1516         if (cfg->fc_flags & RTF_GATEWAY) {
1517                 const struct in6_addr *gw_addr;
1518                 int gwa_type;
1519
1520                 gw_addr = &cfg->fc_gateway;
1521                 rt->rt6i_gateway = *gw_addr;
1522                 gwa_type = ipv6_addr_type(gw_addr);
1523
1524                 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1525                         struct rt6_info *grt;
1526
1527                         /* IPv6 strictly inhibits using not link-local
1528                            addresses as nexthop address.
1529                            Otherwise, router will not able to send redirects.
1530                            It is very good, but in some (rare!) circumstances
1531                            (SIT, PtP, NBMA NOARP links) it is handy to allow
1532                            some exceptions. --ANK
1533                          */
1534                         err = -EINVAL;
1535                         if (!(gwa_type & IPV6_ADDR_UNICAST))
1536                                 goto out;
1537
1538                         grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1539
1540                         err = -EHOSTUNREACH;
1541                         if (!grt)
1542                                 goto out;
1543                         if (dev) {
1544                                 if (dev != grt->dst.dev) {
1545                                         ip6_rt_put(grt);
1546                                         goto out;
1547                                 }
1548                         } else {
1549                                 dev = grt->dst.dev;
1550                                 idev = grt->rt6i_idev;
1551                                 dev_hold(dev);
1552                                 in6_dev_hold(grt->rt6i_idev);
1553                         }
1554                         if (!(grt->rt6i_flags & RTF_GATEWAY))
1555                                 err = 0;
1556                         ip6_rt_put(grt);
1557
1558                         if (err)
1559                                 goto out;
1560                 }
1561                 err = -EINVAL;
1562                 if (!dev || (dev->flags & IFF_LOOPBACK))
1563                         goto out;
1564         }
1565
1566         err = -ENODEV;
1567         if (!dev)
1568                 goto out;
1569
1570         if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1571                 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1572                         err = -EINVAL;
1573                         goto out;
1574                 }
1575                 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1576                 rt->rt6i_prefsrc.plen = 128;
1577         } else
1578                 rt->rt6i_prefsrc.plen = 0;
1579
1580         rt->rt6i_flags = cfg->fc_flags;
1581
1582 install_route:
1583         if (cfg->fc_mx) {
1584                 struct nlattr *nla;
1585                 int remaining;
1586
1587                 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1588                         int type = nla_type(nla);
1589
1590                         if (type) {
1591                                 if (type > RTAX_MAX) {
1592                                         err = -EINVAL;
1593                                         goto out;
1594                                 }
1595
1596                                 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1597                         }
1598                 }
1599         }
1600
1601         rt->dst.dev = dev;
1602         rt->rt6i_idev = idev;
1603         rt->rt6i_table = table;
1604
1605         cfg->fc_nlinfo.nl_net = dev_net(dev);
1606
1607         return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1608
1609 out:
1610         if (dev)
1611                 dev_put(dev);
1612         if (idev)
1613                 in6_dev_put(idev);
1614         if (rt)
1615                 dst_free(&rt->dst);
1616         return err;
1617 }
1618
1619 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1620 {
1621         int err;
1622         struct fib6_table *table;
1623         struct net *net = dev_net(rt->dst.dev);
1624
1625         if (rt == net->ipv6.ip6_null_entry) {
1626                 err = -ENOENT;
1627                 goto out;
1628         }
1629
1630         table = rt->rt6i_table;
1631         write_lock_bh(&table->tb6_lock);
1632         err = fib6_del(rt, info);
1633         write_unlock_bh(&table->tb6_lock);
1634
1635 out:
1636         ip6_rt_put(rt);
1637         return err;
1638 }
1639
1640 int ip6_del_rt(struct rt6_info *rt)
1641 {
1642         struct nl_info info = {
1643                 .nl_net = dev_net(rt->dst.dev),
1644         };
1645         return __ip6_del_rt(rt, &info);
1646 }
1647
1648 static int ip6_route_del(struct fib6_config *cfg)
1649 {
1650         struct fib6_table *table;
1651         struct fib6_node *fn;
1652         struct rt6_info *rt;
1653         int err = -ESRCH;
1654
1655         table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1656         if (!table)
1657                 return err;
1658
1659         read_lock_bh(&table->tb6_lock);
1660
1661         fn = fib6_locate(&table->tb6_root,
1662                          &cfg->fc_dst, cfg->fc_dst_len,
1663                          &cfg->fc_src, cfg->fc_src_len);
1664
1665         if (fn) {
1666                 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1667                         if (cfg->fc_ifindex &&
1668                             (!rt->dst.dev ||
1669                              rt->dst.dev->ifindex != cfg->fc_ifindex))
1670                                 continue;
1671                         if (cfg->fc_flags & RTF_GATEWAY &&
1672                             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1673                                 continue;
1674                         if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1675                                 continue;
1676                         dst_hold(&rt->dst);
1677                         read_unlock_bh(&table->tb6_lock);
1678
1679                         return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1680                 }
1681         }
1682         read_unlock_bh(&table->tb6_lock);
1683
1684         return err;
1685 }
1686
1687 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1688 {
1689         struct net *net = dev_net(skb->dev);
1690         struct netevent_redirect netevent;
1691         struct rt6_info *rt, *nrt = NULL;
1692         struct ndisc_options ndopts;
1693         struct inet6_dev *in6_dev;
1694         struct neighbour *neigh;
1695         struct rd_msg *msg;
1696         int optlen, on_link;
1697         u8 *lladdr;
1698
1699         optlen = skb->tail - skb->transport_header;
1700         optlen -= sizeof(*msg);
1701
1702         if (optlen < 0) {
1703                 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1704                 return;
1705         }
1706
1707         msg = (struct rd_msg *)icmp6_hdr(skb);
1708
1709         if (ipv6_addr_is_multicast(&msg->dest)) {
1710                 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1711                 return;
1712         }
1713
1714         on_link = 0;
1715         if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1716                 on_link = 1;
1717         } else if (ipv6_addr_type(&msg->target) !=
1718                    (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1719                 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1720                 return;
1721         }
1722
1723         in6_dev = __in6_dev_get(skb->dev);
1724         if (!in6_dev)
1725                 return;
1726         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1727                 return;
1728
1729         /* RFC2461 8.1:
1730          *      The IP source address of the Redirect MUST be the same as the current
1731          *      first-hop router for the specified ICMP Destination Address.
1732          */
1733
1734         if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1735                 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1736                 return;
1737         }
1738
1739         lladdr = NULL;
1740         if (ndopts.nd_opts_tgt_lladdr) {
1741                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1742                                              skb->dev);
1743                 if (!lladdr) {
1744                         net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1745                         return;
1746                 }
1747         }
1748
1749         rt = (struct rt6_info *) dst;
1750         if (rt == net->ipv6.ip6_null_entry) {
1751                 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1752                 return;
1753         }
1754
1755         /* Redirect received -> path was valid.
1756          * Look, redirects are sent only in response to data packets,
1757          * so that this nexthop apparently is reachable. --ANK
1758          */
1759         dst_confirm(&rt->dst);
1760
1761         neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1762         if (!neigh)
1763                 return;
1764
1765         /*
1766          *      We have finally decided to accept it.
1767          */
1768
1769         neigh_update(neigh, lladdr, NUD_STALE,
1770                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
1771                      NEIGH_UPDATE_F_OVERRIDE|
1772                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1773                                      NEIGH_UPDATE_F_ISROUTER))
1774                      );
1775
1776         nrt = ip6_rt_copy(rt, &msg->dest);
1777         if (!nrt)
1778                 goto out;
1779
1780         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1781         if (on_link)
1782                 nrt->rt6i_flags &= ~RTF_GATEWAY;
1783
1784         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1785
1786         if (ip6_ins_rt(nrt))
1787                 goto out;
1788
1789         netevent.old = &rt->dst;
1790         netevent.new = &nrt->dst;
1791         netevent.daddr = &msg->dest;
1792         netevent.neigh = neigh;
1793         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1794
1795         if (rt->rt6i_flags & RTF_CACHE) {
1796                 rt = (struct rt6_info *) dst_clone(&rt->dst);
1797                 ip6_del_rt(rt);
1798         }
1799
1800 out:
1801         neigh_release(neigh);
1802 }
1803
1804 /*
1805  *      Misc support functions
1806  */
1807
1808 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1809                                     const struct in6_addr *dest)
1810 {
1811         struct net *net = dev_net(ort->dst.dev);
1812         struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1813                                             ort->rt6i_table);
1814
1815         if (rt) {
1816                 rt->dst.input = ort->dst.input;
1817                 rt->dst.output = ort->dst.output;
1818                 rt->dst.flags |= DST_HOST;
1819
1820                 rt->rt6i_dst.addr = *dest;
1821                 rt->rt6i_dst.plen = 128;
1822                 dst_copy_metrics(&rt->dst, &ort->dst);
1823                 rt->dst.error = ort->dst.error;
1824                 rt->rt6i_idev = ort->rt6i_idev;
1825                 if (rt->rt6i_idev)
1826                         in6_dev_hold(rt->rt6i_idev);
1827                 rt->dst.lastuse = jiffies;
1828
1829                 if (ort->rt6i_flags & RTF_GATEWAY)
1830                         rt->rt6i_gateway = ort->rt6i_gateway;
1831                 else
1832                         rt->rt6i_gateway = *dest;
1833                 rt->rt6i_flags = ort->rt6i_flags;
1834                 rt6_set_from(rt, ort);
1835                 rt->rt6i_metric = 0;
1836
1837 #ifdef CONFIG_IPV6_SUBTREES
1838                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1839 #endif
1840                 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1841                 rt->rt6i_table = ort->rt6i_table;
1842         }
1843         return rt;
1844 }
1845
1846 #ifdef CONFIG_IPV6_ROUTE_INFO
1847 static struct rt6_info *rt6_get_route_info(struct net_device *dev,
1848                                            const struct in6_addr *prefix, int prefixlen,
1849                                            const struct in6_addr *gwaddr)
1850 {
1851         struct fib6_node *fn;
1852         struct rt6_info *rt = NULL;
1853         struct fib6_table *table;
1854
1855         table = fib6_get_table(dev_net(dev),
1856                                addrconf_rt_table(dev, RT6_TABLE_INFO));
1857         if (!table)
1858                 return NULL;
1859
1860         read_lock_bh(&table->tb6_lock);
1861         fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1862         if (!fn)
1863                 goto out;
1864
1865         for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1866                 if (rt->dst.dev->ifindex != dev->ifindex)
1867                         continue;
1868                 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1869                         continue;
1870                 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1871                         continue;
1872                 dst_hold(&rt->dst);
1873                 break;
1874         }
1875 out:
1876         read_unlock_bh(&table->tb6_lock);
1877         return rt;
1878 }
1879
1880 static struct rt6_info *rt6_add_route_info(struct net_device *dev,
1881                                            const struct in6_addr *prefix, int prefixlen,
1882                                            const struct in6_addr *gwaddr, unsigned int pref)
1883 {
1884         struct fib6_config cfg = {
1885                 .fc_table       = addrconf_rt_table(dev, RT6_TABLE_INFO),
1886                 .fc_metric      = IP6_RT_PRIO_USER,
1887                 .fc_ifindex     = dev->ifindex,
1888                 .fc_dst_len     = prefixlen,
1889                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1890                                   RTF_UP | RTF_PREF(pref),
1891                 .fc_nlinfo.portid = 0,
1892                 .fc_nlinfo.nlh = NULL,
1893                 .fc_nlinfo.nl_net = dev_net(dev),
1894         };
1895
1896         cfg.fc_dst = *prefix;
1897         cfg.fc_gateway = *gwaddr;
1898
1899         /* We should treat it as a default route if prefix length is 0. */
1900         if (!prefixlen)
1901                 cfg.fc_flags |= RTF_DEFAULT;
1902
1903         ip6_route_add(&cfg);
1904
1905         return rt6_get_route_info(dev, prefix, prefixlen, gwaddr);
1906 }
1907 #endif
1908
1909 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1910 {
1911         struct rt6_info *rt;
1912         struct fib6_table *table;
1913
1914         table = fib6_get_table(dev_net(dev),
1915                                addrconf_rt_table(dev, RT6_TABLE_MAIN));
1916         if (!table)
1917                 return NULL;
1918
1919         read_lock_bh(&table->tb6_lock);
1920         for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1921                 if (dev == rt->dst.dev &&
1922                     ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1923                     ipv6_addr_equal(&rt->rt6i_gateway, addr))
1924                         break;
1925         }
1926         if (rt)
1927                 dst_hold(&rt->dst);
1928         read_unlock_bh(&table->tb6_lock);
1929         return rt;
1930 }
1931
1932 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1933                                      struct net_device *dev,
1934                                      unsigned int pref)
1935 {
1936         struct fib6_config cfg = {
1937                 .fc_table       = addrconf_rt_table(dev, RT6_TABLE_DFLT),
1938                 .fc_metric      = IP6_RT_PRIO_USER,
1939                 .fc_ifindex     = dev->ifindex,
1940                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1941                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1942                 .fc_nlinfo.portid = 0,
1943                 .fc_nlinfo.nlh = NULL,
1944                 .fc_nlinfo.nl_net = dev_net(dev),
1945         };
1946
1947         cfg.fc_gateway = *gwaddr;
1948
1949         ip6_route_add(&cfg);
1950
1951         return rt6_get_dflt_router(gwaddr, dev);
1952 }
1953
1954
1955 int rt6_addrconf_purge(struct rt6_info *rt, void *arg) {
1956         if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
1957             (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2))
1958                 return -1;
1959         return 0;
1960 }
1961
1962 void rt6_purge_dflt_routers(struct net *net)
1963 {
1964         fib6_clean_all(net, rt6_addrconf_purge, 0, NULL);
1965 }
1966
1967 static void rtmsg_to_fib6_config(struct net *net,
1968                                  struct in6_rtmsg *rtmsg,
1969                                  struct fib6_config *cfg)
1970 {
1971         memset(cfg, 0, sizeof(*cfg));
1972
1973         cfg->fc_table = RT6_TABLE_MAIN;
1974         cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1975         cfg->fc_metric = rtmsg->rtmsg_metric;
1976         cfg->fc_expires = rtmsg->rtmsg_info;
1977         cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1978         cfg->fc_src_len = rtmsg->rtmsg_src_len;
1979         cfg->fc_flags = rtmsg->rtmsg_flags;
1980
1981         cfg->fc_nlinfo.nl_net = net;
1982
1983         cfg->fc_dst = rtmsg->rtmsg_dst;
1984         cfg->fc_src = rtmsg->rtmsg_src;
1985         cfg->fc_gateway = rtmsg->rtmsg_gateway;
1986 }
1987
1988 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1989 {
1990         struct fib6_config cfg;
1991         struct in6_rtmsg rtmsg;
1992         int err;
1993
1994         switch(cmd) {
1995         case SIOCADDRT:         /* Add a route */
1996         case SIOCDELRT:         /* Delete a route */
1997                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1998                         return -EPERM;
1999                 err = copy_from_user(&rtmsg, arg,
2000                                      sizeof(struct in6_rtmsg));
2001                 if (err)
2002                         return -EFAULT;
2003
2004                 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2005
2006                 rtnl_lock();
2007                 switch (cmd) {
2008                 case SIOCADDRT:
2009                         err = ip6_route_add(&cfg);
2010                         break;
2011                 case SIOCDELRT:
2012                         err = ip6_route_del(&cfg);
2013                         break;
2014                 default:
2015                         err = -EINVAL;
2016                 }
2017                 rtnl_unlock();
2018
2019                 return err;
2020         }
2021
2022         return -EINVAL;
2023 }
2024
2025 /*
2026  *      Drop the packet on the floor
2027  */
2028
2029 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2030 {
2031         int type;
2032         struct dst_entry *dst = skb_dst(skb);
2033         switch (ipstats_mib_noroutes) {
2034         case IPSTATS_MIB_INNOROUTES:
2035                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2036                 if (type == IPV6_ADDR_ANY) {
2037                         IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2038                                       IPSTATS_MIB_INADDRERRORS);
2039                         break;
2040                 }
2041                 /* FALLTHROUGH */
2042         case IPSTATS_MIB_OUTNOROUTES:
2043                 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2044                               ipstats_mib_noroutes);
2045                 break;
2046         }
2047         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2048         kfree_skb(skb);
2049         return 0;
2050 }
2051
2052 static int ip6_pkt_discard(struct sk_buff *skb)
2053 {
2054         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2055 }
2056
2057 static int ip6_pkt_discard_out(struct sk_buff *skb)
2058 {
2059         skb->dev = skb_dst(skb)->dev;
2060         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2061 }
2062
2063 static int ip6_pkt_prohibit(struct sk_buff *skb)
2064 {
2065         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2066 }
2067
2068 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2069 {
2070         skb->dev = skb_dst(skb)->dev;
2071         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2072 }
2073
2074 /*
2075  *      Allocate a dst for local (unicast / anycast) address.
2076  */
2077
2078 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2079                                     const struct in6_addr *addr,
2080                                     bool anycast)
2081 {
2082         struct net *net = dev_net(idev->dev);
2083         struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2084                                             DST_NOCOUNT, NULL);
2085         if (!rt)
2086                 return ERR_PTR(-ENOMEM);
2087
2088         in6_dev_hold(idev);
2089
2090         rt->dst.flags |= DST_HOST;
2091         rt->dst.input = ip6_input;
2092         rt->dst.output = ip6_output;
2093         rt->rt6i_idev = idev;
2094
2095         rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2096         if (anycast)
2097                 rt->rt6i_flags |= RTF_ANYCAST;
2098         else
2099                 rt->rt6i_flags |= RTF_LOCAL;
2100
2101         rt->rt6i_gateway  = *addr;
2102         rt->rt6i_dst.addr = *addr;
2103         rt->rt6i_dst.plen = 128;
2104         rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2105
2106         atomic_set(&rt->dst.__refcnt, 1);
2107
2108         return rt;
2109 }
2110
2111 int ip6_route_get_saddr(struct net *net,
2112                         struct rt6_info *rt,
2113                         const struct in6_addr *daddr,
2114                         unsigned int prefs,
2115                         struct in6_addr *saddr)
2116 {
2117         struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2118         int err = 0;
2119         if (rt->rt6i_prefsrc.plen)
2120                 *saddr = rt->rt6i_prefsrc.addr;
2121         else
2122                 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2123                                          daddr, prefs, saddr);
2124         return err;
2125 }
2126
2127 /* remove deleted ip from prefsrc entries */
2128 struct arg_dev_net_ip {
2129         struct net_device *dev;
2130         struct net *net;
2131         struct in6_addr *addr;
2132 };
2133
2134 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2135 {
2136         struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2137         struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2138         struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2139
2140         if (((void *)rt->dst.dev == dev || !dev) &&
2141             rt != net->ipv6.ip6_null_entry &&
2142             ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2143                 /* remove prefsrc entry */
2144                 rt->rt6i_prefsrc.plen = 0;
2145         }
2146         return 0;
2147 }
2148
2149 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2150 {
2151         struct net *net = dev_net(ifp->idev->dev);
2152         struct arg_dev_net_ip adni = {
2153                 .dev = ifp->idev->dev,
2154                 .net = net,
2155                 .addr = &ifp->addr,
2156         };
2157         fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2158 }
2159
2160 struct arg_dev_net {
2161         struct net_device *dev;
2162         struct net *net;
2163 };
2164
2165 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2166 {
2167         const struct arg_dev_net *adn = arg;
2168         const struct net_device *dev = adn->dev;
2169
2170         if ((rt->dst.dev == dev || !dev) &&
2171             rt != adn->net->ipv6.ip6_null_entry)
2172                 return -1;
2173
2174         return 0;
2175 }
2176
2177 void rt6_ifdown(struct net *net, struct net_device *dev)
2178 {
2179         struct arg_dev_net adn = {
2180                 .dev = dev,
2181                 .net = net,
2182         };
2183
2184         fib6_clean_all(net, fib6_ifdown, 0, &adn);
2185         icmp6_clean_all(fib6_ifdown, &adn);
2186 }
2187
2188 struct rt6_mtu_change_arg {
2189         struct net_device *dev;
2190         unsigned int mtu;
2191 };
2192
2193 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2194 {
2195         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2196         struct inet6_dev *idev;
2197
2198         /* In IPv6 pmtu discovery is not optional,
2199            so that RTAX_MTU lock cannot disable it.
2200            We still use this lock to block changes
2201            caused by addrconf/ndisc.
2202         */
2203
2204         idev = __in6_dev_get(arg->dev);
2205         if (!idev)
2206                 return 0;
2207
2208         /* For administrative MTU increase, there is no way to discover
2209            IPv6 PMTU increase, so PMTU increase should be updated here.
2210            Since RFC 1981 doesn't include administrative MTU increase
2211            update PMTU increase is a MUST. (i.e. jumbo frame)
2212          */
2213         /*
2214            If new MTU is less than route PMTU, this new MTU will be the
2215            lowest MTU in the path, update the route PMTU to reflect PMTU
2216            decreases; if new MTU is greater than route PMTU, and the
2217            old MTU is the lowest MTU in the path, update the route PMTU
2218            to reflect the increase. In this case if the other nodes' MTU
2219            also have the lowest MTU, TOO BIG MESSAGE will be lead to
2220            PMTU discouvery.
2221          */
2222         if (rt->dst.dev == arg->dev &&
2223             !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2224             (dst_mtu(&rt->dst) >= arg->mtu ||
2225              (dst_mtu(&rt->dst) < arg->mtu &&
2226               dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2227                 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2228         }
2229         return 0;
2230 }
2231
2232 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2233 {
2234         struct rt6_mtu_change_arg arg = {
2235                 .dev = dev,
2236                 .mtu = mtu,
2237         };
2238
2239         fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2240 }
2241
2242 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2243         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2244         [RTA_OIF]               = { .type = NLA_U32 },
2245         [RTA_IIF]               = { .type = NLA_U32 },
2246         [RTA_PRIORITY]          = { .type = NLA_U32 },
2247         [RTA_METRICS]           = { .type = NLA_NESTED },
2248         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
2249         [RTA_UID]               = { .type = NLA_U32 },
2250 };
2251
2252 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2253                               struct fib6_config *cfg)
2254 {
2255         struct rtmsg *rtm;
2256         struct nlattr *tb[RTA_MAX+1];
2257         int err;
2258
2259         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2260         if (err < 0)
2261                 goto errout;
2262
2263         err = -EINVAL;
2264         rtm = nlmsg_data(nlh);
2265         memset(cfg, 0, sizeof(*cfg));
2266
2267         cfg->fc_table = rtm->rtm_table;
2268         cfg->fc_dst_len = rtm->rtm_dst_len;
2269         cfg->fc_src_len = rtm->rtm_src_len;
2270         cfg->fc_flags = RTF_UP;
2271         cfg->fc_protocol = rtm->rtm_protocol;
2272         cfg->fc_type = rtm->rtm_type;
2273
2274         if (rtm->rtm_type == RTN_UNREACHABLE ||
2275             rtm->rtm_type == RTN_BLACKHOLE ||
2276             rtm->rtm_type == RTN_PROHIBIT ||
2277             rtm->rtm_type == RTN_THROW)
2278                 cfg->fc_flags |= RTF_REJECT;
2279
2280         if (rtm->rtm_type == RTN_LOCAL)
2281                 cfg->fc_flags |= RTF_LOCAL;
2282
2283         cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2284         cfg->fc_nlinfo.nlh = nlh;
2285         cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2286
2287         if (tb[RTA_GATEWAY]) {
2288                 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2289                 cfg->fc_flags |= RTF_GATEWAY;
2290         }
2291
2292         if (tb[RTA_DST]) {
2293                 int plen = (rtm->rtm_dst_len + 7) >> 3;
2294
2295                 if (nla_len(tb[RTA_DST]) < plen)
2296                         goto errout;
2297
2298                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2299         }
2300
2301         if (tb[RTA_SRC]) {
2302                 int plen = (rtm->rtm_src_len + 7) >> 3;
2303
2304                 if (nla_len(tb[RTA_SRC]) < plen)
2305                         goto errout;
2306
2307                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2308         }
2309
2310         if (tb[RTA_PREFSRC])
2311                 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2312
2313         if (tb[RTA_OIF])
2314                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2315
2316         if (tb[RTA_PRIORITY])
2317                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2318
2319         if (tb[RTA_METRICS]) {
2320                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2321                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2322         }
2323
2324         if (tb[RTA_TABLE])
2325                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2326
2327         if (tb[RTA_MULTIPATH]) {
2328                 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2329                 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2330         }
2331
2332         err = 0;
2333 errout:
2334         return err;
2335 }
2336
2337 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2338 {
2339         struct fib6_config r_cfg;
2340         struct rtnexthop *rtnh;
2341         int remaining;
2342         int attrlen;
2343         int err = 0, last_err = 0;
2344
2345 beginning:
2346         rtnh = (struct rtnexthop *)cfg->fc_mp;
2347         remaining = cfg->fc_mp_len;
2348
2349         /* Parse a Multipath Entry */
2350         while (rtnh_ok(rtnh, remaining)) {
2351                 memcpy(&r_cfg, cfg, sizeof(*cfg));
2352                 if (rtnh->rtnh_ifindex)
2353                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2354
2355                 attrlen = rtnh_attrlen(rtnh);
2356                 if (attrlen > 0) {
2357                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2358
2359                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2360                         if (nla) {
2361                                 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2362                                 r_cfg.fc_flags |= RTF_GATEWAY;
2363                         }
2364                 }
2365                 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2366                 if (err) {
2367                         last_err = err;
2368                         /* If we are trying to remove a route, do not stop the
2369                          * loop when ip6_route_del() fails (because next hop is
2370                          * already gone), we should try to remove all next hops.
2371                          */
2372                         if (add) {
2373                                 /* If add fails, we should try to delete all
2374                                  * next hops that have been already added.
2375                                  */
2376                                 add = 0;
2377                                 goto beginning;
2378                         }
2379                 }
2380                 /* Because each route is added like a single route we remove
2381                  * this flag after the first nexthop (if there is a collision,
2382                  * we have already fail to add the first nexthop:
2383                  * fib6_add_rt2node() has reject it).
2384                  */
2385                 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2386                 rtnh = rtnh_next(rtnh, &remaining);
2387         }
2388
2389         return last_err;
2390 }
2391
2392 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2393 {
2394         struct fib6_config cfg;
2395         int err;
2396
2397         err = rtm_to_fib6_config(skb, nlh, &cfg);
2398         if (err < 0)
2399                 return err;
2400
2401         if (cfg.fc_mp)
2402                 return ip6_route_multipath(&cfg, 0);
2403         else
2404                 return ip6_route_del(&cfg);
2405 }
2406
2407 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2408 {
2409         struct fib6_config cfg;
2410         int err;
2411
2412         err = rtm_to_fib6_config(skb, nlh, &cfg);
2413         if (err < 0)
2414                 return err;
2415
2416         if (cfg.fc_mp)
2417                 return ip6_route_multipath(&cfg, 1);
2418         else
2419                 return ip6_route_add(&cfg);
2420 }
2421
2422 static inline size_t rt6_nlmsg_size(void)
2423 {
2424         return NLMSG_ALIGN(sizeof(struct rtmsg))
2425                + nla_total_size(16) /* RTA_SRC */
2426                + nla_total_size(16) /* RTA_DST */
2427                + nla_total_size(16) /* RTA_GATEWAY */
2428                + nla_total_size(16) /* RTA_PREFSRC */
2429                + nla_total_size(4) /* RTA_TABLE */
2430                + nla_total_size(4) /* RTA_IIF */
2431                + nla_total_size(4) /* RTA_OIF */
2432                + nla_total_size(4) /* RTA_PRIORITY */
2433                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2434                + nla_total_size(sizeof(struct rta_cacheinfo));
2435 }
2436
2437 static int rt6_fill_node(struct net *net,
2438                          struct sk_buff *skb, struct rt6_info *rt,
2439                          struct in6_addr *dst, struct in6_addr *src,
2440                          int iif, int type, u32 portid, u32 seq,
2441                          int prefix, int nowait, unsigned int flags)
2442 {
2443         struct rtmsg *rtm;
2444         struct nlmsghdr *nlh;
2445         long expires;
2446         u32 table;
2447
2448         if (prefix) {   /* user wants prefix routes only */
2449                 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2450                         /* success since this is not a prefix route */
2451                         return 1;
2452                 }
2453         }
2454
2455         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2456         if (!nlh)
2457                 return -EMSGSIZE;
2458
2459         rtm = nlmsg_data(nlh);
2460         rtm->rtm_family = AF_INET6;
2461         rtm->rtm_dst_len = rt->rt6i_dst.plen;
2462         rtm->rtm_src_len = rt->rt6i_src.plen;
2463         rtm->rtm_tos = 0;
2464         if (rt->rt6i_table)
2465                 table = rt->rt6i_table->tb6_id;
2466         else
2467                 table = RT6_TABLE_UNSPEC;
2468         rtm->rtm_table = table;
2469         if (nla_put_u32(skb, RTA_TABLE, table))
2470                 goto nla_put_failure;
2471         if (rt->rt6i_flags & RTF_REJECT) {
2472                 switch (rt->dst.error) {
2473                 case -EINVAL:
2474                         rtm->rtm_type = RTN_BLACKHOLE;
2475                         break;
2476                 case -EACCES:
2477                         rtm->rtm_type = RTN_PROHIBIT;
2478                         break;
2479                 case -EAGAIN:
2480                         rtm->rtm_type = RTN_THROW;
2481                         break;
2482                 default:
2483                         rtm->rtm_type = RTN_UNREACHABLE;
2484                         break;
2485                 }
2486         }
2487         else if (rt->rt6i_flags & RTF_LOCAL)
2488                 rtm->rtm_type = RTN_LOCAL;
2489         else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2490                 rtm->rtm_type = RTN_LOCAL;
2491         else
2492                 rtm->rtm_type = RTN_UNICAST;
2493         rtm->rtm_flags = 0;
2494         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2495         rtm->rtm_protocol = rt->rt6i_protocol;
2496         if (rt->rt6i_flags & RTF_DYNAMIC)
2497                 rtm->rtm_protocol = RTPROT_REDIRECT;
2498         else if (rt->rt6i_flags & RTF_ADDRCONF) {
2499                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2500                         rtm->rtm_protocol = RTPROT_RA;
2501                 else
2502                         rtm->rtm_protocol = RTPROT_KERNEL;
2503         }
2504
2505         if (rt->rt6i_flags & RTF_CACHE)
2506                 rtm->rtm_flags |= RTM_F_CLONED;
2507
2508         if (dst) {
2509                 if (nla_put(skb, RTA_DST, 16, dst))
2510                         goto nla_put_failure;
2511                 rtm->rtm_dst_len = 128;
2512         } else if (rtm->rtm_dst_len)
2513                 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2514                         goto nla_put_failure;
2515 #ifdef CONFIG_IPV6_SUBTREES
2516         if (src) {
2517                 if (nla_put(skb, RTA_SRC, 16, src))
2518                         goto nla_put_failure;
2519                 rtm->rtm_src_len = 128;
2520         } else if (rtm->rtm_src_len &&
2521                    nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2522                 goto nla_put_failure;
2523 #endif
2524         if (iif) {
2525 #ifdef CONFIG_IPV6_MROUTE
2526                 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2527                         int err = ip6mr_get_route(net, skb, rtm, nowait);
2528                         if (err <= 0) {
2529                                 if (!nowait) {
2530                                         if (err == 0)
2531                                                 return 0;
2532                                         goto nla_put_failure;
2533                                 } else {
2534                                         if (err == -EMSGSIZE)
2535                                                 goto nla_put_failure;
2536                                 }
2537                         }
2538                 } else
2539 #endif
2540                         if (nla_put_u32(skb, RTA_IIF, iif))
2541                                 goto nla_put_failure;
2542         } else if (dst) {
2543                 struct in6_addr saddr_buf;
2544                 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2545                     nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2546                         goto nla_put_failure;
2547         }
2548
2549         if (rt->rt6i_prefsrc.plen) {
2550                 struct in6_addr saddr_buf;
2551                 saddr_buf = rt->rt6i_prefsrc.addr;
2552                 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2553                         goto nla_put_failure;
2554         }
2555
2556         if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2557                 goto nla_put_failure;
2558
2559         if (rt->rt6i_flags & RTF_GATEWAY) {
2560                 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2561                         goto nla_put_failure;
2562         }
2563
2564         if (rt->dst.dev &&
2565             nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2566                 goto nla_put_failure;
2567         if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2568                 goto nla_put_failure;
2569
2570         expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2571
2572         if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2573                 goto nla_put_failure;
2574
2575         return nlmsg_end(skb, nlh);
2576
2577 nla_put_failure:
2578         nlmsg_cancel(skb, nlh);
2579         return -EMSGSIZE;
2580 }
2581
2582 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2583 {
2584         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2585         int prefix;
2586
2587         if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2588                 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2589                 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2590         } else
2591                 prefix = 0;
2592
2593         return rt6_fill_node(arg->net,
2594                      arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2595                      NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2596                      prefix, 0, NLM_F_MULTI);
2597 }
2598
2599 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh)
2600 {
2601         struct net *net = sock_net(in_skb->sk);
2602         struct nlattr *tb[RTA_MAX+1];
2603         struct rt6_info *rt;
2604         struct sk_buff *skb;
2605         struct rtmsg *rtm;
2606         struct flowi6 fl6;
2607         int err, iif = 0, oif = 0;
2608
2609         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2610         if (err < 0)
2611                 goto errout;
2612
2613         err = -EINVAL;
2614         memset(&fl6, 0, sizeof(fl6));
2615
2616         if (tb[RTA_SRC]) {
2617                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2618                         goto errout;
2619
2620                 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2621         }
2622
2623         if (tb[RTA_DST]) {
2624                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2625                         goto errout;
2626
2627                 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2628         }
2629
2630         if (tb[RTA_IIF])
2631                 iif = nla_get_u32(tb[RTA_IIF]);
2632
2633         if (tb[RTA_OIF])
2634                 oif = nla_get_u32(tb[RTA_OIF]);
2635
2636         if (tb[RTA_MARK])
2637                 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2638
2639         if (tb[RTA_UID])
2640                 fl6.flowi6_uid = make_kuid(current_user_ns(),
2641                                            nla_get_u32(tb[RTA_UID]));
2642         else
2643                 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
2644
2645         if (iif) {
2646                 struct net_device *dev;
2647                 int flags = 0;
2648
2649                 dev = __dev_get_by_index(net, iif);
2650                 if (!dev) {
2651                         err = -ENODEV;
2652                         goto errout;
2653                 }
2654
2655                 fl6.flowi6_iif = iif;
2656
2657                 if (!ipv6_addr_any(&fl6.saddr))
2658                         flags |= RT6_LOOKUP_F_HAS_SADDR;
2659
2660                 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2661                                                                flags);
2662         } else {
2663                 fl6.flowi6_oif = oif;
2664
2665                 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2666         }
2667
2668         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2669         if (!skb) {
2670                 ip6_rt_put(rt);
2671                 err = -ENOBUFS;
2672                 goto errout;
2673         }
2674
2675         /* Reserve room for dummy headers, this skb can pass
2676            through good chunk of routing engine.
2677          */
2678         skb_reset_mac_header(skb);
2679         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2680
2681         skb_dst_set(skb, &rt->dst);
2682
2683         err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2684                             RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2685                             nlh->nlmsg_seq, 0, 0, 0);
2686         if (err < 0) {
2687                 kfree_skb(skb);
2688                 goto errout;
2689         }
2690
2691         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2692 errout:
2693         return err;
2694 }
2695
2696 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2697 {
2698         struct sk_buff *skb;
2699         struct net *net = info->nl_net;
2700         u32 seq;
2701         int err;
2702
2703         err = -ENOBUFS;
2704         seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2705
2706         skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2707         if (!skb)
2708                 goto errout;
2709
2710         err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2711                                 event, info->portid, seq, 0, 0, 0);
2712         if (err < 0) {
2713                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2714                 WARN_ON(err == -EMSGSIZE);
2715                 kfree_skb(skb);
2716                 goto errout;
2717         }
2718         rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2719                     info->nlh, gfp_any());
2720         return;
2721 errout:
2722         if (err < 0)
2723                 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2724 }
2725
2726 static int ip6_route_dev_notify(struct notifier_block *this,
2727                                 unsigned long event, void *data)
2728 {
2729         struct net_device *dev = (struct net_device *)data;
2730         struct net *net = dev_net(dev);
2731
2732         if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2733                 net->ipv6.ip6_null_entry->dst.dev = dev;
2734                 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2735 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2736                 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2737                 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2738                 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2739                 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2740 #endif
2741         }
2742
2743         return NOTIFY_OK;
2744 }
2745
2746 /*
2747  *      /proc
2748  */
2749
2750 #ifdef CONFIG_PROC_FS
2751
2752 struct rt6_proc_arg
2753 {
2754         char *buffer;
2755         int offset;
2756         int length;
2757         int skip;
2758         int len;
2759 };
2760
2761 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2762 {
2763         struct seq_file *m = p_arg;
2764
2765         seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2766
2767 #ifdef CONFIG_IPV6_SUBTREES
2768         seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2769 #else
2770         seq_puts(m, "00000000000000000000000000000000 00 ");
2771 #endif
2772         if (rt->rt6i_flags & RTF_GATEWAY) {
2773                 seq_printf(m, "%pi6", &rt->rt6i_gateway);
2774         } else {
2775                 seq_puts(m, "00000000000000000000000000000000");
2776         }
2777         seq_printf(m, " %08x %08x %08x %08x %8s\n",
2778                    rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2779                    rt->dst.__use, rt->rt6i_flags,
2780                    rt->dst.dev ? rt->dst.dev->name : "");
2781         return 0;
2782 }
2783
2784 static int ipv6_route_show(struct seq_file *m, void *v)
2785 {
2786         struct net *net = (struct net *)m->private;
2787         fib6_clean_all_ro(net, rt6_info_route, 0, m);
2788         return 0;
2789 }
2790
2791 static int ipv6_route_open(struct inode *inode, struct file *file)
2792 {
2793         return single_open_net(inode, file, ipv6_route_show);
2794 }
2795
2796 static const struct file_operations ipv6_route_proc_fops = {
2797         .owner          = THIS_MODULE,
2798         .open           = ipv6_route_open,
2799         .read           = seq_read,
2800         .llseek         = seq_lseek,
2801         .release        = single_release_net,
2802 };
2803
2804 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2805 {
2806         struct net *net = (struct net *)seq->private;
2807         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2808                    net->ipv6.rt6_stats->fib_nodes,
2809                    net->ipv6.rt6_stats->fib_route_nodes,
2810                    net->ipv6.rt6_stats->fib_rt_alloc,
2811                    net->ipv6.rt6_stats->fib_rt_entries,
2812                    net->ipv6.rt6_stats->fib_rt_cache,
2813                    dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2814                    net->ipv6.rt6_stats->fib_discarded_routes);
2815
2816         return 0;
2817 }
2818
2819 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2820 {
2821         return single_open_net(inode, file, rt6_stats_seq_show);
2822 }
2823
2824 static const struct file_operations rt6_stats_seq_fops = {
2825         .owner   = THIS_MODULE,
2826         .open    = rt6_stats_seq_open,
2827         .read    = seq_read,
2828         .llseek  = seq_lseek,
2829         .release = single_release_net,
2830 };
2831 #endif  /* CONFIG_PROC_FS */
2832
2833 #ifdef CONFIG_SYSCTL
2834
2835 static
2836 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2837                               void __user *buffer, size_t *lenp, loff_t *ppos)
2838 {
2839         struct net *net;
2840         int delay;
2841         if (!write)
2842                 return -EINVAL;
2843
2844         net = (struct net *)ctl->extra1;
2845         delay = net->ipv6.sysctl.flush_delay;
2846         proc_dointvec(ctl, write, buffer, lenp, ppos);
2847         fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2848         return 0;
2849 }
2850
2851 ctl_table ipv6_route_table_template[] = {
2852         {
2853                 .procname       =       "flush",
2854                 .data           =       &init_net.ipv6.sysctl.flush_delay,
2855                 .maxlen         =       sizeof(int),
2856                 .mode           =       0200,
2857                 .proc_handler   =       ipv6_sysctl_rtcache_flush
2858         },
2859         {
2860                 .procname       =       "gc_thresh",
2861                 .data           =       &ip6_dst_ops_template.gc_thresh,
2862                 .maxlen         =       sizeof(int),
2863                 .mode           =       0644,
2864                 .proc_handler   =       proc_dointvec,
2865         },
2866         {
2867                 .procname       =       "max_size",
2868                 .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
2869                 .maxlen         =       sizeof(int),
2870                 .mode           =       0644,
2871                 .proc_handler   =       proc_dointvec,
2872         },
2873         {
2874                 .procname       =       "gc_min_interval",
2875                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2876                 .maxlen         =       sizeof(int),
2877                 .mode           =       0644,
2878                 .proc_handler   =       proc_dointvec_jiffies,
2879         },
2880         {
2881                 .procname       =       "gc_timeout",
2882                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2883                 .maxlen         =       sizeof(int),
2884                 .mode           =       0644,
2885                 .proc_handler   =       proc_dointvec_jiffies,
2886         },
2887         {
2888                 .procname       =       "gc_interval",
2889                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2890                 .maxlen         =       sizeof(int),
2891                 .mode           =       0644,
2892                 .proc_handler   =       proc_dointvec_jiffies,
2893         },
2894         {
2895                 .procname       =       "gc_elasticity",
2896                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2897                 .maxlen         =       sizeof(int),
2898                 .mode           =       0644,
2899                 .proc_handler   =       proc_dointvec,
2900         },
2901         {
2902                 .procname       =       "mtu_expires",
2903                 .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2904                 .maxlen         =       sizeof(int),
2905                 .mode           =       0644,
2906                 .proc_handler   =       proc_dointvec_jiffies,
2907         },
2908         {
2909                 .procname       =       "min_adv_mss",
2910                 .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2911                 .maxlen         =       sizeof(int),
2912                 .mode           =       0644,
2913                 .proc_handler   =       proc_dointvec,
2914         },
2915         {
2916                 .procname       =       "gc_min_interval_ms",
2917                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2918                 .maxlen         =       sizeof(int),
2919                 .mode           =       0644,
2920                 .proc_handler   =       proc_dointvec_ms_jiffies,
2921         },
2922         { }
2923 };
2924
2925 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2926 {
2927         struct ctl_table *table;
2928
2929         table = kmemdup(ipv6_route_table_template,
2930                         sizeof(ipv6_route_table_template),
2931                         GFP_KERNEL);
2932
2933         if (table) {
2934                 table[0].data = &net->ipv6.sysctl.flush_delay;
2935                 table[0].extra1 = net;
2936                 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2937                 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2938                 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2939                 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2940                 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2941                 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2942                 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2943                 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2944                 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2945
2946                 /* Don't export sysctls to unprivileged users */
2947                 if (net->user_ns != &init_user_ns)
2948                         table[0].procname = NULL;
2949         }
2950
2951         return table;
2952 }
2953 #endif
2954
2955 static int __net_init ip6_route_net_init(struct net *net)
2956 {
2957         int ret = -ENOMEM;
2958
2959         memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2960                sizeof(net->ipv6.ip6_dst_ops));
2961
2962         if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2963                 goto out_ip6_dst_ops;
2964
2965         net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2966                                            sizeof(*net->ipv6.ip6_null_entry),
2967                                            GFP_KERNEL);
2968         if (!net->ipv6.ip6_null_entry)
2969                 goto out_ip6_dst_entries;
2970         net->ipv6.ip6_null_entry->dst.path =
2971                 (struct dst_entry *)net->ipv6.ip6_null_entry;
2972         net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2973         dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2974                          ip6_template_metrics, true);
2975
2976 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2977         net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2978                                                sizeof(*net->ipv6.ip6_prohibit_entry),
2979                                                GFP_KERNEL);
2980         if (!net->ipv6.ip6_prohibit_entry)
2981                 goto out_ip6_null_entry;
2982         net->ipv6.ip6_prohibit_entry->dst.path =
2983                 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2984         net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2985         dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
2986                          ip6_template_metrics, true);
2987
2988         net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2989                                                sizeof(*net->ipv6.ip6_blk_hole_entry),
2990                                                GFP_KERNEL);
2991         if (!net->ipv6.ip6_blk_hole_entry)
2992                 goto out_ip6_prohibit_entry;
2993         net->ipv6.ip6_blk_hole_entry->dst.path =
2994                 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2995         net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2996         dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
2997                          ip6_template_metrics, true);
2998 #endif
2999
3000         net->ipv6.sysctl.flush_delay = 0;
3001         net->ipv6.sysctl.ip6_rt_max_size = 4096;
3002         net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3003         net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3004         net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3005         net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3006         net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3007         net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3008
3009         net->ipv6.ip6_rt_gc_expire = 30*HZ;
3010
3011         ret = 0;
3012 out:
3013         return ret;
3014
3015 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3016 out_ip6_prohibit_entry:
3017         kfree(net->ipv6.ip6_prohibit_entry);
3018 out_ip6_null_entry:
3019         kfree(net->ipv6.ip6_null_entry);
3020 #endif
3021 out_ip6_dst_entries:
3022         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3023 out_ip6_dst_ops:
3024         goto out;
3025 }
3026
3027 static void __net_exit ip6_route_net_exit(struct net *net)
3028 {
3029         kfree(net->ipv6.ip6_null_entry);
3030 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3031         kfree(net->ipv6.ip6_prohibit_entry);
3032         kfree(net->ipv6.ip6_blk_hole_entry);
3033 #endif
3034         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3035 }
3036
3037 static int __net_init ip6_route_net_init_late(struct net *net)
3038 {
3039 #ifdef CONFIG_PROC_FS
3040         proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3041         proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3042 #endif
3043         return 0;
3044 }
3045
3046 static void __net_exit ip6_route_net_exit_late(struct net *net)
3047 {
3048 #ifdef CONFIG_PROC_FS
3049         remove_proc_entry("ipv6_route", net->proc_net);
3050         remove_proc_entry("rt6_stats", net->proc_net);
3051 #endif
3052 }
3053
3054 static struct pernet_operations ip6_route_net_ops = {
3055         .init = ip6_route_net_init,
3056         .exit = ip6_route_net_exit,
3057 };
3058
3059 static int __net_init ipv6_inetpeer_init(struct net *net)
3060 {
3061         struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3062
3063         if (!bp)
3064                 return -ENOMEM;
3065         inet_peer_base_init(bp);
3066         net->ipv6.peers = bp;
3067         return 0;
3068 }
3069
3070 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3071 {
3072         struct inet_peer_base *bp = net->ipv6.peers;
3073
3074         net->ipv6.peers = NULL;
3075         inetpeer_invalidate_tree(bp);
3076         kfree(bp);
3077 }
3078
3079 static struct pernet_operations ipv6_inetpeer_ops = {
3080         .init   =       ipv6_inetpeer_init,
3081         .exit   =       ipv6_inetpeer_exit,
3082 };
3083
3084 static struct pernet_operations ip6_route_net_late_ops = {
3085         .init = ip6_route_net_init_late,
3086         .exit = ip6_route_net_exit_late,
3087 };
3088
3089 static struct notifier_block ip6_route_dev_notifier = {
3090         .notifier_call = ip6_route_dev_notify,
3091         .priority = 0,
3092 };
3093
3094 int __init ip6_route_init(void)
3095 {
3096         int ret;
3097
3098         ret = -ENOMEM;
3099         ip6_dst_ops_template.kmem_cachep =
3100                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3101                                   SLAB_HWCACHE_ALIGN, NULL);
3102         if (!ip6_dst_ops_template.kmem_cachep)
3103                 goto out;
3104
3105         ret = dst_entries_init(&ip6_dst_blackhole_ops);
3106         if (ret)
3107                 goto out_kmem_cache;
3108
3109         ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3110         if (ret)
3111                 goto out_dst_entries;
3112
3113         ret = register_pernet_subsys(&ip6_route_net_ops);
3114         if (ret)
3115                 goto out_register_inetpeer;
3116
3117         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3118
3119         /* Registering of the loopback is done before this portion of code,
3120          * the loopback reference in rt6_info will not be taken, do it
3121          * manually for init_net */
3122         init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3123         init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3124   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3125         init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3126         init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3127         init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3128         init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3129   #endif
3130         ret = fib6_init();
3131         if (ret)
3132                 goto out_register_subsys;
3133
3134         ret = xfrm6_init();
3135         if (ret)
3136                 goto out_fib6_init;
3137
3138         ret = fib6_rules_init();
3139         if (ret)
3140                 goto xfrm6_init;
3141
3142         ret = register_pernet_subsys(&ip6_route_net_late_ops);
3143         if (ret)
3144                 goto fib6_rules_init;
3145
3146         ret = -ENOBUFS;
3147         if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3148             __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3149             __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3150                 goto out_register_late_subsys;
3151
3152         ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3153         if (ret)
3154                 goto out_register_late_subsys;
3155
3156 out:
3157         return ret;
3158
3159 out_register_late_subsys:
3160         unregister_pernet_subsys(&ip6_route_net_late_ops);
3161 fib6_rules_init:
3162         fib6_rules_cleanup();
3163 xfrm6_init:
3164         xfrm6_fini();
3165 out_fib6_init:
3166         fib6_gc_cleanup();
3167 out_register_subsys:
3168         unregister_pernet_subsys(&ip6_route_net_ops);
3169 out_register_inetpeer:
3170         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3171 out_dst_entries:
3172         dst_entries_destroy(&ip6_dst_blackhole_ops);
3173 out_kmem_cache:
3174         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3175         goto out;
3176 }
3177
3178 void ip6_route_cleanup(void)
3179 {
3180         unregister_netdevice_notifier(&ip6_route_dev_notifier);
3181         unregister_pernet_subsys(&ip6_route_net_late_ops);
3182         fib6_rules_cleanup();
3183         xfrm6_fini();
3184         fib6_gc_cleanup();
3185         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3186         unregister_pernet_subsys(&ip6_route_net_ops);
3187         dst_entries_destroy(&ip6_dst_blackhole_ops);
3188         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3189 }