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 NULL;
 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                         u32 features = dst_metric(dst, RTAX_FEATURES);
1142                         mtu = IPV6_MIN_MTU;
1143                         features |= RTAX_FEATURE_ALLFRAG;
1144                         dst_metric_set(dst, RTAX_FEATURES, features);
1145                 }
1146                 dst_metric_set(dst, RTAX_MTU, mtu);
1147                 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1148         }
1149 }
1150
1151 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1152                      int oif, u32 mark)
1153 {
1154         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1155         struct dst_entry *dst;
1156         struct flowi6 fl6;
1157
1158         memset(&fl6, 0, sizeof(fl6));
1159         fl6.flowi6_oif = oif;
1160         fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1161         fl6.flowi6_flags = 0;
1162         fl6.daddr = iph->daddr;
1163         fl6.saddr = iph->saddr;
1164         fl6.flowlabel = ip6_flowinfo(iph);
1165
1166         dst = ip6_route_output(net, NULL, &fl6);
1167         if (!dst->error)
1168                 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1169         dst_release(dst);
1170 }
1171 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1172
1173 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1174 {
1175         ip6_update_pmtu(skb, sock_net(sk), mtu,
1176                         sk->sk_bound_dev_if, sk->sk_mark);
1177 }
1178 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1179
1180 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1181 {
1182         const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1183         struct dst_entry *dst;
1184         struct flowi6 fl6;
1185
1186         memset(&fl6, 0, sizeof(fl6));
1187         fl6.flowi6_oif = oif;
1188         fl6.flowi6_mark = mark;
1189         fl6.flowi6_flags = 0;
1190         fl6.daddr = iph->daddr;
1191         fl6.saddr = iph->saddr;
1192         fl6.flowlabel = ip6_flowinfo(iph);
1193
1194         dst = ip6_route_output(net, NULL, &fl6);
1195         if (!dst->error)
1196                 rt6_do_redirect(dst, NULL, skb);
1197         dst_release(dst);
1198 }
1199 EXPORT_SYMBOL_GPL(ip6_redirect);
1200
1201 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1202 {
1203         ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1204 }
1205 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1206
1207 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1208 {
1209         struct net_device *dev = dst->dev;
1210         unsigned int mtu = dst_mtu(dst);
1211         struct net *net = dev_net(dev);
1212
1213         mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1214
1215         if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1216                 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1217
1218         /*
1219          * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1220          * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1221          * IPV6_MAXPLEN is also valid and means: "any MSS,
1222          * rely only on pmtu discovery"
1223          */
1224         if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1225                 mtu = IPV6_MAXPLEN;
1226         return mtu;
1227 }
1228
1229 static unsigned int ip6_mtu(const struct dst_entry *dst)
1230 {
1231         struct inet6_dev *idev;
1232         unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1233
1234         if (mtu)
1235                 goto out;
1236
1237         mtu = IPV6_MIN_MTU;
1238
1239         rcu_read_lock();
1240         idev = __in6_dev_get(dst->dev);
1241         if (idev)
1242                 mtu = idev->cnf.mtu6;
1243         rcu_read_unlock();
1244
1245 out:
1246         return min_t(unsigned int, mtu, IP6_MAX_MTU);
1247 }
1248
1249 static struct dst_entry *icmp6_dst_gc_list;
1250 static DEFINE_SPINLOCK(icmp6_dst_lock);
1251
1252 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1253                                   struct flowi6 *fl6)
1254 {
1255         struct dst_entry *dst;
1256         struct rt6_info *rt;
1257         struct inet6_dev *idev = in6_dev_get(dev);
1258         struct net *net = dev_net(dev);
1259
1260         if (unlikely(!idev))
1261                 return ERR_PTR(-ENODEV);
1262
1263         rt = ip6_dst_alloc(net, dev, 0, NULL);
1264         if (unlikely(!rt)) {
1265                 in6_dev_put(idev);
1266                 dst = ERR_PTR(-ENOMEM);
1267                 goto out;
1268         }
1269
1270         rt->dst.flags |= DST_HOST;
1271         rt->dst.output  = ip6_output;
1272         atomic_set(&rt->dst.__refcnt, 1);
1273         rt->rt6i_gateway  = fl6->daddr;
1274         rt->rt6i_dst.addr = fl6->daddr;
1275         rt->rt6i_dst.plen = 128;
1276         rt->rt6i_idev     = idev;
1277         dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1278
1279         spin_lock_bh(&icmp6_dst_lock);
1280         rt->dst.next = icmp6_dst_gc_list;
1281         icmp6_dst_gc_list = &rt->dst;
1282         spin_unlock_bh(&icmp6_dst_lock);
1283
1284         fib6_force_start_gc(net);
1285
1286         dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1287
1288 out:
1289         return dst;
1290 }
1291
1292 int icmp6_dst_gc(void)
1293 {
1294         struct dst_entry *dst, **pprev;
1295         int more = 0;
1296
1297         spin_lock_bh(&icmp6_dst_lock);
1298         pprev = &icmp6_dst_gc_list;
1299
1300         while ((dst = *pprev) != NULL) {
1301                 if (!atomic_read(&dst->__refcnt)) {
1302                         *pprev = dst->next;
1303                         dst_free(dst);
1304                 } else {
1305                         pprev = &dst->next;
1306                         ++more;
1307                 }
1308         }
1309
1310         spin_unlock_bh(&icmp6_dst_lock);
1311
1312         return more;
1313 }
1314
1315 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1316                             void *arg)
1317 {
1318         struct dst_entry *dst, **pprev;
1319
1320         spin_lock_bh(&icmp6_dst_lock);
1321         pprev = &icmp6_dst_gc_list;
1322         while ((dst = *pprev) != NULL) {
1323                 struct rt6_info *rt = (struct rt6_info *) dst;
1324                 if (func(rt, arg)) {
1325                         *pprev = dst->next;
1326                         dst_free(dst);
1327                 } else {
1328                         pprev = &dst->next;
1329                 }
1330         }
1331         spin_unlock_bh(&icmp6_dst_lock);
1332 }
1333
1334 static int ip6_dst_gc(struct dst_ops *ops)
1335 {
1336         unsigned long now = jiffies;
1337         struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1338         int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1339         int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1340         int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1341         int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1342         unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1343         int entries;
1344
1345         entries = dst_entries_get_fast(ops);
1346         if (time_after(rt_last_gc + rt_min_interval, now) &&
1347             entries <= rt_max_size)
1348                 goto out;
1349
1350         net->ipv6.ip6_rt_gc_expire++;
1351         fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1352         net->ipv6.ip6_rt_last_gc = now;
1353         entries = dst_entries_get_slow(ops);
1354         if (entries < ops->gc_thresh)
1355                 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1356 out:
1357         net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1358         return entries > rt_max_size;
1359 }
1360
1361 int ip6_dst_hoplimit(struct dst_entry *dst)
1362 {
1363         int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1364         if (hoplimit == 0) {
1365                 struct net_device *dev = dst->dev;
1366                 struct inet6_dev *idev;
1367
1368                 rcu_read_lock();
1369                 idev = __in6_dev_get(dev);
1370                 if (idev)
1371                         hoplimit = idev->cnf.hop_limit;
1372                 else
1373                         hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1374                 rcu_read_unlock();
1375         }
1376         return hoplimit;
1377 }
1378 EXPORT_SYMBOL(ip6_dst_hoplimit);
1379
1380 /*
1381  *
1382  */
1383
1384 int ip6_route_add(struct fib6_config *cfg)
1385 {
1386         int err;
1387         struct net *net = cfg->fc_nlinfo.nl_net;
1388         struct rt6_info *rt = NULL;
1389         struct net_device *dev = NULL;
1390         struct inet6_dev *idev = NULL;
1391         struct fib6_table *table;
1392         int addr_type;
1393
1394         if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1395                 return -EINVAL;
1396 #ifndef CONFIG_IPV6_SUBTREES
1397         if (cfg->fc_src_len)
1398                 return -EINVAL;
1399 #endif
1400         if (cfg->fc_ifindex) {
1401                 err = -ENODEV;
1402                 dev = dev_get_by_index(net, cfg->fc_ifindex);
1403                 if (!dev)
1404                         goto out;
1405                 idev = in6_dev_get(dev);
1406                 if (!idev)
1407                         goto out;
1408         }
1409
1410         if (cfg->fc_metric == 0)
1411                 cfg->fc_metric = IP6_RT_PRIO_USER;
1412
1413         err = -ENOBUFS;
1414         if (cfg->fc_nlinfo.nlh &&
1415             !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1416                 table = fib6_get_table(net, cfg->fc_table);
1417                 if (!table) {
1418                         pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1419                         table = fib6_new_table(net, cfg->fc_table);
1420                 }
1421         } else {
1422                 table = fib6_new_table(net, cfg->fc_table);
1423         }
1424
1425         if (!table)
1426                 goto out;
1427
1428         rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1429
1430         if (!rt) {
1431                 err = -ENOMEM;
1432                 goto out;
1433         }
1434
1435         if (cfg->fc_flags & RTF_EXPIRES)
1436                 rt6_set_expires(rt, jiffies +
1437                                 clock_t_to_jiffies(cfg->fc_expires));
1438         else
1439                 rt6_clean_expires(rt);
1440
1441         if (cfg->fc_protocol == RTPROT_UNSPEC)
1442                 cfg->fc_protocol = RTPROT_BOOT;
1443         rt->rt6i_protocol = cfg->fc_protocol;
1444
1445         addr_type = ipv6_addr_type(&cfg->fc_dst);
1446
1447         if (addr_type & IPV6_ADDR_MULTICAST)
1448                 rt->dst.input = ip6_mc_input;
1449         else if (cfg->fc_flags & RTF_LOCAL)
1450                 rt->dst.input = ip6_input;
1451         else
1452                 rt->dst.input = ip6_forward;
1453
1454         rt->dst.output = ip6_output;
1455
1456         ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1457         rt->rt6i_dst.plen = cfg->fc_dst_len;
1458         if (rt->rt6i_dst.plen == 128)
1459                rt->dst.flags |= DST_HOST;
1460
1461         if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1462                 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1463                 if (!metrics) {
1464                         err = -ENOMEM;
1465                         goto out;
1466                 }
1467                 dst_init_metrics(&rt->dst, metrics, 0);
1468         }
1469 #ifdef CONFIG_IPV6_SUBTREES
1470         ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1471         rt->rt6i_src.plen = cfg->fc_src_len;
1472 #endif
1473
1474         rt->rt6i_metric = cfg->fc_metric;
1475
1476         /* We cannot add true routes via loopback here,
1477            they would result in kernel looping; promote them to reject routes
1478          */
1479         if ((cfg->fc_flags & RTF_REJECT) ||
1480             (dev && (dev->flags & IFF_LOOPBACK) &&
1481              !(addr_type & IPV6_ADDR_LOOPBACK) &&
1482              !(cfg->fc_flags & RTF_LOCAL))) {
1483                 /* hold loopback dev/idev if we haven't done so. */
1484                 if (dev != net->loopback_dev) {
1485                         if (dev) {
1486                                 dev_put(dev);
1487                                 in6_dev_put(idev);
1488                         }
1489                         dev = net->loopback_dev;
1490                         dev_hold(dev);
1491                         idev = in6_dev_get(dev);
1492                         if (!idev) {
1493                                 err = -ENODEV;
1494                                 goto out;
1495                         }
1496                 }
1497                 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1498                 switch (cfg->fc_type) {
1499                 case RTN_BLACKHOLE:
1500                         rt->dst.error = -EINVAL;
1501                         rt->dst.output = dst_discard;
1502                         rt->dst.input = dst_discard;
1503                         break;
1504                 case RTN_PROHIBIT:
1505                         rt->dst.error = -EACCES;
1506                         rt->dst.output = ip6_pkt_prohibit_out;
1507                         rt->dst.input = ip6_pkt_prohibit;
1508                         break;
1509                 case RTN_THROW:
1510                 default:
1511                         rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1512                                         : -ENETUNREACH;
1513                         rt->dst.output = ip6_pkt_discard_out;
1514                         rt->dst.input = ip6_pkt_discard;
1515                         break;
1516                 }
1517                 goto install_route;
1518         }
1519
1520         if (cfg->fc_flags & RTF_GATEWAY) {
1521                 const struct in6_addr *gw_addr;
1522                 int gwa_type;
1523
1524                 gw_addr = &cfg->fc_gateway;
1525                 rt->rt6i_gateway = *gw_addr;
1526                 gwa_type = ipv6_addr_type(gw_addr);
1527
1528                 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1529                         struct rt6_info *grt;
1530
1531                         /* IPv6 strictly inhibits using not link-local
1532                            addresses as nexthop address.
1533                            Otherwise, router will not able to send redirects.
1534                            It is very good, but in some (rare!) circumstances
1535                            (SIT, PtP, NBMA NOARP links) it is handy to allow
1536                            some exceptions. --ANK
1537                          */
1538                         err = -EINVAL;
1539                         if (!(gwa_type & IPV6_ADDR_UNICAST))
1540                                 goto out;
1541
1542                         grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1543
1544                         err = -EHOSTUNREACH;
1545                         if (!grt)
1546                                 goto out;
1547                         if (dev) {
1548                                 if (dev != grt->dst.dev) {
1549                                         ip6_rt_put(grt);
1550                                         goto out;
1551                                 }
1552                         } else {
1553                                 dev = grt->dst.dev;
1554                                 idev = grt->rt6i_idev;
1555                                 dev_hold(dev);
1556                                 in6_dev_hold(grt->rt6i_idev);
1557                         }
1558                         if (!(grt->rt6i_flags & RTF_GATEWAY))
1559                                 err = 0;
1560                         ip6_rt_put(grt);
1561
1562                         if (err)
1563                                 goto out;
1564                 }
1565                 err = -EINVAL;
1566                 if (!dev || (dev->flags & IFF_LOOPBACK))
1567                         goto out;
1568         }
1569
1570         err = -ENODEV;
1571         if (!dev)
1572                 goto out;
1573
1574         if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1575                 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1576                         err = -EINVAL;
1577                         goto out;
1578                 }
1579                 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1580                 rt->rt6i_prefsrc.plen = 128;
1581         } else
1582                 rt->rt6i_prefsrc.plen = 0;
1583
1584         rt->rt6i_flags = cfg->fc_flags;
1585
1586 install_route:
1587         if (cfg->fc_mx) {
1588                 struct nlattr *nla;
1589                 int remaining;
1590
1591                 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1592                         int type = nla_type(nla);
1593
1594                         if (type) {
1595                                 if (type > RTAX_MAX) {
1596                                         err = -EINVAL;
1597                                         goto out;
1598                                 }
1599
1600                                 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1601                         }
1602                 }
1603         }
1604
1605         rt->dst.dev = dev;
1606         rt->rt6i_idev = idev;
1607         rt->rt6i_table = table;
1608
1609         cfg->fc_nlinfo.nl_net = dev_net(dev);
1610
1611         return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1612
1613 out:
1614         if (dev)
1615                 dev_put(dev);
1616         if (idev)
1617                 in6_dev_put(idev);
1618         if (rt)
1619                 dst_free(&rt->dst);
1620         return err;
1621 }
1622
1623 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1624 {
1625         int err;
1626         struct fib6_table *table;
1627         struct net *net = dev_net(rt->dst.dev);
1628
1629         if (rt == net->ipv6.ip6_null_entry) {
1630                 err = -ENOENT;
1631                 goto out;
1632         }
1633
1634         table = rt->rt6i_table;
1635         write_lock_bh(&table->tb6_lock);
1636         err = fib6_del(rt, info);
1637         write_unlock_bh(&table->tb6_lock);
1638
1639 out:
1640         ip6_rt_put(rt);
1641         return err;
1642 }
1643
1644 int ip6_del_rt(struct rt6_info *rt)
1645 {
1646         struct nl_info info = {
1647                 .nl_net = dev_net(rt->dst.dev),
1648         };
1649         return __ip6_del_rt(rt, &info);
1650 }
1651
1652 static int ip6_route_del(struct fib6_config *cfg)
1653 {
1654         struct fib6_table *table;
1655         struct fib6_node *fn;
1656         struct rt6_info *rt;
1657         int err = -ESRCH;
1658
1659         table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1660         if (!table)
1661                 return err;
1662
1663         read_lock_bh(&table->tb6_lock);
1664
1665         fn = fib6_locate(&table->tb6_root,
1666                          &cfg->fc_dst, cfg->fc_dst_len,
1667                          &cfg->fc_src, cfg->fc_src_len);
1668
1669         if (fn) {
1670                 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1671                         if (cfg->fc_ifindex &&
1672                             (!rt->dst.dev ||
1673                              rt->dst.dev->ifindex != cfg->fc_ifindex))
1674                                 continue;
1675                         if (cfg->fc_flags & RTF_GATEWAY &&
1676                             !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1677                                 continue;
1678                         if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1679                                 continue;
1680                         dst_hold(&rt->dst);
1681                         read_unlock_bh(&table->tb6_lock);
1682
1683                         return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1684                 }
1685         }
1686         read_unlock_bh(&table->tb6_lock);
1687
1688         return err;
1689 }
1690
1691 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1692 {
1693         struct net *net = dev_net(skb->dev);
1694         struct netevent_redirect netevent;
1695         struct rt6_info *rt, *nrt = NULL;
1696         struct ndisc_options ndopts;
1697         struct inet6_dev *in6_dev;
1698         struct neighbour *neigh;
1699         struct rd_msg *msg;
1700         int optlen, on_link;
1701         u8 *lladdr;
1702
1703         optlen = skb->tail - skb->transport_header;
1704         optlen -= sizeof(*msg);
1705
1706         if (optlen < 0) {
1707                 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1708                 return;
1709         }
1710
1711         msg = (struct rd_msg *)icmp6_hdr(skb);
1712
1713         if (ipv6_addr_is_multicast(&msg->dest)) {
1714                 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1715                 return;
1716         }
1717
1718         on_link = 0;
1719         if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1720                 on_link = 1;
1721         } else if (ipv6_addr_type(&msg->target) !=
1722                    (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1723                 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1724                 return;
1725         }
1726
1727         in6_dev = __in6_dev_get(skb->dev);
1728         if (!in6_dev)
1729                 return;
1730         if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1731                 return;
1732
1733         /* RFC2461 8.1:
1734          *      The IP source address of the Redirect MUST be the same as the current
1735          *      first-hop router for the specified ICMP Destination Address.
1736          */
1737
1738         if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1739                 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1740                 return;
1741         }
1742
1743         lladdr = NULL;
1744         if (ndopts.nd_opts_tgt_lladdr) {
1745                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1746                                              skb->dev);
1747                 if (!lladdr) {
1748                         net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1749                         return;
1750                 }
1751         }
1752
1753         rt = (struct rt6_info *) dst;
1754         if (rt == net->ipv6.ip6_null_entry) {
1755                 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1756                 return;
1757         }
1758
1759         /* Redirect received -> path was valid.
1760          * Look, redirects are sent only in response to data packets,
1761          * so that this nexthop apparently is reachable. --ANK
1762          */
1763         dst_confirm(&rt->dst);
1764
1765         neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1766         if (!neigh)
1767                 return;
1768
1769         /*
1770          *      We have finally decided to accept it.
1771          */
1772
1773         neigh_update(neigh, lladdr, NUD_STALE,
1774                      NEIGH_UPDATE_F_WEAK_OVERRIDE|
1775                      NEIGH_UPDATE_F_OVERRIDE|
1776                      (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1777                                      NEIGH_UPDATE_F_ISROUTER))
1778                      );
1779
1780         nrt = ip6_rt_copy(rt, &msg->dest);
1781         if (!nrt)
1782                 goto out;
1783
1784         nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1785         if (on_link)
1786                 nrt->rt6i_flags &= ~RTF_GATEWAY;
1787
1788         nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1789
1790         if (ip6_ins_rt(nrt))
1791                 goto out;
1792
1793         netevent.old = &rt->dst;
1794         netevent.new = &nrt->dst;
1795         netevent.daddr = &msg->dest;
1796         netevent.neigh = neigh;
1797         call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1798
1799         if (rt->rt6i_flags & RTF_CACHE) {
1800                 rt = (struct rt6_info *) dst_clone(&rt->dst);
1801                 ip6_del_rt(rt);
1802         }
1803
1804 out:
1805         neigh_release(neigh);
1806 }
1807
1808 /*
1809  *      Misc support functions
1810  */
1811
1812 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1813                                     const struct in6_addr *dest)
1814 {
1815         struct net *net = dev_net(ort->dst.dev);
1816         struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1817                                             ort->rt6i_table);
1818
1819         if (rt) {
1820                 rt->dst.input = ort->dst.input;
1821                 rt->dst.output = ort->dst.output;
1822                 rt->dst.flags |= DST_HOST;
1823
1824                 rt->rt6i_dst.addr = *dest;
1825                 rt->rt6i_dst.plen = 128;
1826                 dst_copy_metrics(&rt->dst, &ort->dst);
1827                 rt->dst.error = ort->dst.error;
1828                 rt->rt6i_idev = ort->rt6i_idev;
1829                 if (rt->rt6i_idev)
1830                         in6_dev_hold(rt->rt6i_idev);
1831                 rt->dst.lastuse = jiffies;
1832
1833                 if (ort->rt6i_flags & RTF_GATEWAY)
1834                         rt->rt6i_gateway = ort->rt6i_gateway;
1835                 else
1836                         rt->rt6i_gateway = *dest;
1837                 rt->rt6i_flags = ort->rt6i_flags;
1838                 rt6_set_from(rt, ort);
1839                 rt->rt6i_metric = 0;
1840
1841 #ifdef CONFIG_IPV6_SUBTREES
1842                 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1843 #endif
1844                 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1845                 rt->rt6i_table = ort->rt6i_table;
1846         }
1847         return rt;
1848 }
1849
1850 #ifdef CONFIG_IPV6_ROUTE_INFO
1851 static struct rt6_info *rt6_get_route_info(struct net_device *dev,
1852                                            const struct in6_addr *prefix, int prefixlen,
1853                                            const struct in6_addr *gwaddr)
1854 {
1855         struct fib6_node *fn;
1856         struct rt6_info *rt = NULL;
1857         struct fib6_table *table;
1858
1859         table = fib6_get_table(dev_net(dev),
1860                                addrconf_rt_table(dev, RT6_TABLE_INFO));
1861         if (!table)
1862                 return NULL;
1863
1864         read_lock_bh(&table->tb6_lock);
1865         fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1866         if (!fn)
1867                 goto out;
1868
1869         for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1870                 if (rt->dst.dev->ifindex != dev->ifindex)
1871                         continue;
1872                 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1873                         continue;
1874                 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1875                         continue;
1876                 dst_hold(&rt->dst);
1877                 break;
1878         }
1879 out:
1880         read_unlock_bh(&table->tb6_lock);
1881         return rt;
1882 }
1883
1884 static struct rt6_info *rt6_add_route_info(struct net_device *dev,
1885                                            const struct in6_addr *prefix, int prefixlen,
1886                                            const struct in6_addr *gwaddr, unsigned int pref)
1887 {
1888         struct fib6_config cfg = {
1889                 .fc_table       = addrconf_rt_table(dev, RT6_TABLE_INFO),
1890                 .fc_metric      = IP6_RT_PRIO_USER,
1891                 .fc_ifindex     = dev->ifindex,
1892                 .fc_dst_len     = prefixlen,
1893                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1894                                   RTF_UP | RTF_PREF(pref),
1895                 .fc_nlinfo.portid = 0,
1896                 .fc_nlinfo.nlh = NULL,
1897                 .fc_nlinfo.nl_net = dev_net(dev),
1898         };
1899
1900         cfg.fc_dst = *prefix;
1901         cfg.fc_gateway = *gwaddr;
1902
1903         /* We should treat it as a default route if prefix length is 0. */
1904         if (!prefixlen)
1905                 cfg.fc_flags |= RTF_DEFAULT;
1906
1907         ip6_route_add(&cfg);
1908
1909         return rt6_get_route_info(dev, prefix, prefixlen, gwaddr);
1910 }
1911 #endif
1912
1913 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1914 {
1915         struct rt6_info *rt;
1916         struct fib6_table *table;
1917
1918         table = fib6_get_table(dev_net(dev),
1919                                addrconf_rt_table(dev, RT6_TABLE_MAIN));
1920         if (!table)
1921                 return NULL;
1922
1923         read_lock_bh(&table->tb6_lock);
1924         for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1925                 if (dev == rt->dst.dev &&
1926                     ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1927                     ipv6_addr_equal(&rt->rt6i_gateway, addr))
1928                         break;
1929         }
1930         if (rt)
1931                 dst_hold(&rt->dst);
1932         read_unlock_bh(&table->tb6_lock);
1933         return rt;
1934 }
1935
1936 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1937                                      struct net_device *dev,
1938                                      unsigned int pref)
1939 {
1940         struct fib6_config cfg = {
1941                 .fc_table       = addrconf_rt_table(dev, RT6_TABLE_DFLT),
1942                 .fc_metric      = IP6_RT_PRIO_USER,
1943                 .fc_ifindex     = dev->ifindex,
1944                 .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1945                                   RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1946                 .fc_nlinfo.portid = 0,
1947                 .fc_nlinfo.nlh = NULL,
1948                 .fc_nlinfo.nl_net = dev_net(dev),
1949         };
1950
1951         cfg.fc_gateway = *gwaddr;
1952
1953         ip6_route_add(&cfg);
1954
1955         return rt6_get_dflt_router(gwaddr, dev);
1956 }
1957
1958
1959 int rt6_addrconf_purge(struct rt6_info *rt, void *arg) {
1960         if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
1961             (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2))
1962                 return -1;
1963         return 0;
1964 }
1965
1966 void rt6_purge_dflt_routers(struct net *net)
1967 {
1968         fib6_clean_all(net, rt6_addrconf_purge, 0, NULL);
1969 }
1970
1971 static void rtmsg_to_fib6_config(struct net *net,
1972                                  struct in6_rtmsg *rtmsg,
1973                                  struct fib6_config *cfg)
1974 {
1975         memset(cfg, 0, sizeof(*cfg));
1976
1977         cfg->fc_table = RT6_TABLE_MAIN;
1978         cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1979         cfg->fc_metric = rtmsg->rtmsg_metric;
1980         cfg->fc_expires = rtmsg->rtmsg_info;
1981         cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1982         cfg->fc_src_len = rtmsg->rtmsg_src_len;
1983         cfg->fc_flags = rtmsg->rtmsg_flags;
1984
1985         cfg->fc_nlinfo.nl_net = net;
1986
1987         cfg->fc_dst = rtmsg->rtmsg_dst;
1988         cfg->fc_src = rtmsg->rtmsg_src;
1989         cfg->fc_gateway = rtmsg->rtmsg_gateway;
1990 }
1991
1992 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1993 {
1994         struct fib6_config cfg;
1995         struct in6_rtmsg rtmsg;
1996         int err;
1997
1998         switch(cmd) {
1999         case SIOCADDRT:         /* Add a route */
2000         case SIOCDELRT:         /* Delete a route */
2001                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2002                         return -EPERM;
2003                 err = copy_from_user(&rtmsg, arg,
2004                                      sizeof(struct in6_rtmsg));
2005                 if (err)
2006                         return -EFAULT;
2007
2008                 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2009
2010                 rtnl_lock();
2011                 switch (cmd) {
2012                 case SIOCADDRT:
2013                         err = ip6_route_add(&cfg);
2014                         break;
2015                 case SIOCDELRT:
2016                         err = ip6_route_del(&cfg);
2017                         break;
2018                 default:
2019                         err = -EINVAL;
2020                 }
2021                 rtnl_unlock();
2022
2023                 return err;
2024         }
2025
2026         return -EINVAL;
2027 }
2028
2029 /*
2030  *      Drop the packet on the floor
2031  */
2032
2033 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2034 {
2035         int type;
2036         struct dst_entry *dst = skb_dst(skb);
2037         switch (ipstats_mib_noroutes) {
2038         case IPSTATS_MIB_INNOROUTES:
2039                 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2040                 if (type == IPV6_ADDR_ANY) {
2041                         IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2042                                       IPSTATS_MIB_INADDRERRORS);
2043                         break;
2044                 }
2045                 /* FALLTHROUGH */
2046         case IPSTATS_MIB_OUTNOROUTES:
2047                 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2048                               ipstats_mib_noroutes);
2049                 break;
2050         }
2051         icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2052         kfree_skb(skb);
2053         return 0;
2054 }
2055
2056 static int ip6_pkt_discard(struct sk_buff *skb)
2057 {
2058         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2059 }
2060
2061 static int ip6_pkt_discard_out(struct sk_buff *skb)
2062 {
2063         skb->dev = skb_dst(skb)->dev;
2064         return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2065 }
2066
2067 static int ip6_pkt_prohibit(struct sk_buff *skb)
2068 {
2069         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2070 }
2071
2072 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2073 {
2074         skb->dev = skb_dst(skb)->dev;
2075         return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2076 }
2077
2078 /*
2079  *      Allocate a dst for local (unicast / anycast) address.
2080  */
2081
2082 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2083                                     const struct in6_addr *addr,
2084                                     bool anycast)
2085 {
2086         struct net *net = dev_net(idev->dev);
2087         struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2088                                             DST_NOCOUNT, NULL);
2089         if (!rt)
2090                 return ERR_PTR(-ENOMEM);
2091
2092         in6_dev_hold(idev);
2093
2094         rt->dst.flags |= DST_HOST;
2095         rt->dst.input = ip6_input;
2096         rt->dst.output = ip6_output;
2097         rt->rt6i_idev = idev;
2098
2099         rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2100         if (anycast)
2101                 rt->rt6i_flags |= RTF_ANYCAST;
2102         else
2103                 rt->rt6i_flags |= RTF_LOCAL;
2104
2105         rt->rt6i_gateway  = *addr;
2106         rt->rt6i_dst.addr = *addr;
2107         rt->rt6i_dst.plen = 128;
2108         rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2109
2110         atomic_set(&rt->dst.__refcnt, 1);
2111
2112         return rt;
2113 }
2114
2115 int ip6_route_get_saddr(struct net *net,
2116                         struct rt6_info *rt,
2117                         const struct in6_addr *daddr,
2118                         unsigned int prefs,
2119                         struct in6_addr *saddr)
2120 {
2121         struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2122         int err = 0;
2123         if (rt->rt6i_prefsrc.plen)
2124                 *saddr = rt->rt6i_prefsrc.addr;
2125         else
2126                 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2127                                          daddr, prefs, saddr);
2128         return err;
2129 }
2130
2131 /* remove deleted ip from prefsrc entries */
2132 struct arg_dev_net_ip {
2133         struct net_device *dev;
2134         struct net *net;
2135         struct in6_addr *addr;
2136 };
2137
2138 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2139 {
2140         struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2141         struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2142         struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2143
2144         if (((void *)rt->dst.dev == dev || !dev) &&
2145             rt != net->ipv6.ip6_null_entry &&
2146             ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2147                 /* remove prefsrc entry */
2148                 rt->rt6i_prefsrc.plen = 0;
2149         }
2150         return 0;
2151 }
2152
2153 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2154 {
2155         struct net *net = dev_net(ifp->idev->dev);
2156         struct arg_dev_net_ip adni = {
2157                 .dev = ifp->idev->dev,
2158                 .net = net,
2159                 .addr = &ifp->addr,
2160         };
2161         fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2162 }
2163
2164 struct arg_dev_net {
2165         struct net_device *dev;
2166         struct net *net;
2167 };
2168
2169 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2170 {
2171         const struct arg_dev_net *adn = arg;
2172         const struct net_device *dev = adn->dev;
2173
2174         if ((rt->dst.dev == dev || !dev) &&
2175             rt != adn->net->ipv6.ip6_null_entry)
2176                 return -1;
2177
2178         return 0;
2179 }
2180
2181 void rt6_ifdown(struct net *net, struct net_device *dev)
2182 {
2183         struct arg_dev_net adn = {
2184                 .dev = dev,
2185                 .net = net,
2186         };
2187
2188         fib6_clean_all(net, fib6_ifdown, 0, &adn);
2189         icmp6_clean_all(fib6_ifdown, &adn);
2190 }
2191
2192 struct rt6_mtu_change_arg {
2193         struct net_device *dev;
2194         unsigned int mtu;
2195 };
2196
2197 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2198 {
2199         struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2200         struct inet6_dev *idev;
2201
2202         /* In IPv6 pmtu discovery is not optional,
2203            so that RTAX_MTU lock cannot disable it.
2204            We still use this lock to block changes
2205            caused by addrconf/ndisc.
2206         */
2207
2208         idev = __in6_dev_get(arg->dev);
2209         if (!idev)
2210                 return 0;
2211
2212         /* For administrative MTU increase, there is no way to discover
2213            IPv6 PMTU increase, so PMTU increase should be updated here.
2214            Since RFC 1981 doesn't include administrative MTU increase
2215            update PMTU increase is a MUST. (i.e. jumbo frame)
2216          */
2217         /*
2218            If new MTU is less than route PMTU, this new MTU will be the
2219            lowest MTU in the path, update the route PMTU to reflect PMTU
2220            decreases; if new MTU is greater than route PMTU, and the
2221            old MTU is the lowest MTU in the path, update the route PMTU
2222            to reflect the increase. In this case if the other nodes' MTU
2223            also have the lowest MTU, TOO BIG MESSAGE will be lead to
2224            PMTU discouvery.
2225          */
2226         if (rt->dst.dev == arg->dev &&
2227             !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2228             (dst_mtu(&rt->dst) >= arg->mtu ||
2229              (dst_mtu(&rt->dst) < arg->mtu &&
2230               dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2231                 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2232         }
2233         return 0;
2234 }
2235
2236 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2237 {
2238         struct rt6_mtu_change_arg arg = {
2239                 .dev = dev,
2240                 .mtu = mtu,
2241         };
2242
2243         fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2244 }
2245
2246 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2247         [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2248         [RTA_OIF]               = { .type = NLA_U32 },
2249         [RTA_IIF]               = { .type = NLA_U32 },
2250         [RTA_PRIORITY]          = { .type = NLA_U32 },
2251         [RTA_METRICS]           = { .type = NLA_NESTED },
2252         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
2253 };
2254
2255 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2256                               struct fib6_config *cfg)
2257 {
2258         struct rtmsg *rtm;
2259         struct nlattr *tb[RTA_MAX+1];
2260         int err;
2261
2262         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2263         if (err < 0)
2264                 goto errout;
2265
2266         err = -EINVAL;
2267         rtm = nlmsg_data(nlh);
2268         memset(cfg, 0, sizeof(*cfg));
2269
2270         cfg->fc_table = rtm->rtm_table;
2271         cfg->fc_dst_len = rtm->rtm_dst_len;
2272         cfg->fc_src_len = rtm->rtm_src_len;
2273         cfg->fc_flags = RTF_UP;
2274         cfg->fc_protocol = rtm->rtm_protocol;
2275         cfg->fc_type = rtm->rtm_type;
2276
2277         if (rtm->rtm_type == RTN_UNREACHABLE ||
2278             rtm->rtm_type == RTN_BLACKHOLE ||
2279             rtm->rtm_type == RTN_PROHIBIT ||
2280             rtm->rtm_type == RTN_THROW)
2281                 cfg->fc_flags |= RTF_REJECT;
2282
2283         if (rtm->rtm_type == RTN_LOCAL)
2284                 cfg->fc_flags |= RTF_LOCAL;
2285
2286         cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2287         cfg->fc_nlinfo.nlh = nlh;
2288         cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2289
2290         if (tb[RTA_GATEWAY]) {
2291                 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2292                 cfg->fc_flags |= RTF_GATEWAY;
2293         }
2294
2295         if (tb[RTA_DST]) {
2296                 int plen = (rtm->rtm_dst_len + 7) >> 3;
2297
2298                 if (nla_len(tb[RTA_DST]) < plen)
2299                         goto errout;
2300
2301                 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2302         }
2303
2304         if (tb[RTA_SRC]) {
2305                 int plen = (rtm->rtm_src_len + 7) >> 3;
2306
2307                 if (nla_len(tb[RTA_SRC]) < plen)
2308                         goto errout;
2309
2310                 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2311         }
2312
2313         if (tb[RTA_PREFSRC])
2314                 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2315
2316         if (tb[RTA_OIF])
2317                 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2318
2319         if (tb[RTA_PRIORITY])
2320                 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2321
2322         if (tb[RTA_METRICS]) {
2323                 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2324                 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2325         }
2326
2327         if (tb[RTA_TABLE])
2328                 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2329
2330         if (tb[RTA_MULTIPATH]) {
2331                 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2332                 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2333         }
2334
2335         err = 0;
2336 errout:
2337         return err;
2338 }
2339
2340 static int ip6_route_multipath(struct fib6_config *cfg, int add)
2341 {
2342         struct fib6_config r_cfg;
2343         struct rtnexthop *rtnh;
2344         int remaining;
2345         int attrlen;
2346         int err = 0, last_err = 0;
2347
2348 beginning:
2349         rtnh = (struct rtnexthop *)cfg->fc_mp;
2350         remaining = cfg->fc_mp_len;
2351
2352         /* Parse a Multipath Entry */
2353         while (rtnh_ok(rtnh, remaining)) {
2354                 memcpy(&r_cfg, cfg, sizeof(*cfg));
2355                 if (rtnh->rtnh_ifindex)
2356                         r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2357
2358                 attrlen = rtnh_attrlen(rtnh);
2359                 if (attrlen > 0) {
2360                         struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2361
2362                         nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2363                         if (nla) {
2364                                 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2365                                 r_cfg.fc_flags |= RTF_GATEWAY;
2366                         }
2367                 }
2368                 err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2369                 if (err) {
2370                         last_err = err;
2371                         /* If we are trying to remove a route, do not stop the
2372                          * loop when ip6_route_del() fails (because next hop is
2373                          * already gone), we should try to remove all next hops.
2374                          */
2375                         if (add) {
2376                                 /* If add fails, we should try to delete all
2377                                  * next hops that have been already added.
2378                                  */
2379                                 add = 0;
2380                                 goto beginning;
2381                         }
2382                 }
2383                 /* Because each route is added like a single route we remove
2384                  * this flag after the first nexthop (if there is a collision,
2385                  * we have already fail to add the first nexthop:
2386                  * fib6_add_rt2node() has reject it).
2387                  */
2388                 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2389                 rtnh = rtnh_next(rtnh, &remaining);
2390         }
2391
2392         return last_err;
2393 }
2394
2395 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2396 {
2397         struct fib6_config cfg;
2398         int err;
2399
2400         err = rtm_to_fib6_config(skb, nlh, &cfg);
2401         if (err < 0)
2402                 return err;
2403
2404         if (cfg.fc_mp)
2405                 return ip6_route_multipath(&cfg, 0);
2406         else
2407                 return ip6_route_del(&cfg);
2408 }
2409
2410 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh)
2411 {
2412         struct fib6_config cfg;
2413         int err;
2414
2415         err = rtm_to_fib6_config(skb, nlh, &cfg);
2416         if (err < 0)
2417                 return err;
2418
2419         if (cfg.fc_mp)
2420                 return ip6_route_multipath(&cfg, 1);
2421         else
2422                 return ip6_route_add(&cfg);
2423 }
2424
2425 static inline size_t rt6_nlmsg_size(void)
2426 {
2427         return NLMSG_ALIGN(sizeof(struct rtmsg))
2428                + nla_total_size(16) /* RTA_SRC */
2429                + nla_total_size(16) /* RTA_DST */
2430                + nla_total_size(16) /* RTA_GATEWAY */
2431                + nla_total_size(16) /* RTA_PREFSRC */
2432                + nla_total_size(4) /* RTA_TABLE */
2433                + nla_total_size(4) /* RTA_IIF */
2434                + nla_total_size(4) /* RTA_OIF */
2435                + nla_total_size(4) /* RTA_PRIORITY */
2436                + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2437                + nla_total_size(sizeof(struct rta_cacheinfo));
2438 }
2439
2440 static int rt6_fill_node(struct net *net,
2441                          struct sk_buff *skb, struct rt6_info *rt,
2442                          struct in6_addr *dst, struct in6_addr *src,
2443                          int iif, int type, u32 portid, u32 seq,
2444                          int prefix, int nowait, unsigned int flags)
2445 {
2446         struct rtmsg *rtm;
2447         struct nlmsghdr *nlh;
2448         long expires;
2449         u32 table;
2450
2451         if (prefix) {   /* user wants prefix routes only */
2452                 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2453                         /* success since this is not a prefix route */
2454                         return 1;
2455                 }
2456         }
2457
2458         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2459         if (!nlh)
2460                 return -EMSGSIZE;
2461
2462         rtm = nlmsg_data(nlh);
2463         rtm->rtm_family = AF_INET6;
2464         rtm->rtm_dst_len = rt->rt6i_dst.plen;
2465         rtm->rtm_src_len = rt->rt6i_src.plen;
2466         rtm->rtm_tos = 0;
2467         if (rt->rt6i_table)
2468                 table = rt->rt6i_table->tb6_id;
2469         else
2470                 table = RT6_TABLE_UNSPEC;
2471         rtm->rtm_table = table;
2472         if (nla_put_u32(skb, RTA_TABLE, table))
2473                 goto nla_put_failure;
2474         if (rt->rt6i_flags & RTF_REJECT) {
2475                 switch (rt->dst.error) {
2476                 case -EINVAL:
2477                         rtm->rtm_type = RTN_BLACKHOLE;
2478                         break;
2479                 case -EACCES:
2480                         rtm->rtm_type = RTN_PROHIBIT;
2481                         break;
2482                 case -EAGAIN:
2483                         rtm->rtm_type = RTN_THROW;
2484                         break;
2485                 default:
2486                         rtm->rtm_type = RTN_UNREACHABLE;
2487                         break;
2488                 }
2489         }
2490         else if (rt->rt6i_flags & RTF_LOCAL)
2491                 rtm->rtm_type = RTN_LOCAL;
2492         else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2493                 rtm->rtm_type = RTN_LOCAL;
2494         else
2495                 rtm->rtm_type = RTN_UNICAST;
2496         rtm->rtm_flags = 0;
2497         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2498         rtm->rtm_protocol = rt->rt6i_protocol;
2499         if (rt->rt6i_flags & RTF_DYNAMIC)
2500                 rtm->rtm_protocol = RTPROT_REDIRECT;
2501         else if (rt->rt6i_flags & RTF_ADDRCONF) {
2502                 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2503                         rtm->rtm_protocol = RTPROT_RA;
2504                 else
2505                         rtm->rtm_protocol = RTPROT_KERNEL;
2506         }
2507
2508         if (rt->rt6i_flags & RTF_CACHE)
2509                 rtm->rtm_flags |= RTM_F_CLONED;
2510
2511         if (dst) {
2512                 if (nla_put(skb, RTA_DST, 16, dst))
2513                         goto nla_put_failure;
2514                 rtm->rtm_dst_len = 128;
2515         } else if (rtm->rtm_dst_len)
2516                 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2517                         goto nla_put_failure;
2518 #ifdef CONFIG_IPV6_SUBTREES
2519         if (src) {
2520                 if (nla_put(skb, RTA_SRC, 16, src))
2521                         goto nla_put_failure;
2522                 rtm->rtm_src_len = 128;
2523         } else if (rtm->rtm_src_len &&
2524                    nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2525                 goto nla_put_failure;
2526 #endif
2527         if (iif) {
2528 #ifdef CONFIG_IPV6_MROUTE
2529                 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2530                         int err = ip6mr_get_route(net, skb, rtm, nowait);
2531                         if (err <= 0) {
2532                                 if (!nowait) {
2533                                         if (err == 0)
2534                                                 return 0;
2535                                         goto nla_put_failure;
2536                                 } else {
2537                                         if (err == -EMSGSIZE)
2538                                                 goto nla_put_failure;
2539                                 }
2540                         }
2541                 } else
2542 #endif
2543                         if (nla_put_u32(skb, RTA_IIF, iif))
2544                                 goto nla_put_failure;
2545         } else if (dst) {
2546                 struct in6_addr saddr_buf;
2547                 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2548                     nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2549                         goto nla_put_failure;
2550         }
2551
2552         if (rt->rt6i_prefsrc.plen) {
2553                 struct in6_addr saddr_buf;
2554                 saddr_buf = rt->rt6i_prefsrc.addr;
2555                 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2556                         goto nla_put_failure;
2557         }
2558
2559         if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2560                 goto nla_put_failure;
2561
2562         if (rt->rt6i_flags & RTF_GATEWAY) {
2563                 if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2564                         goto nla_put_failure;
2565         }
2566
2567         if (rt->dst.dev &&
2568             nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2569                 goto nla_put_failure;
2570         if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2571                 goto nla_put_failure;
2572
2573         expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2574
2575         if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2576                 goto nla_put_failure;
2577
2578         return nlmsg_end(skb, nlh);
2579
2580 nla_put_failure:
2581         nlmsg_cancel(skb, nlh);
2582         return -EMSGSIZE;
2583 }
2584
2585 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2586 {
2587         struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2588         int prefix;
2589
2590         if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2591                 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2592                 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2593         } else
2594                 prefix = 0;
2595
2596         return rt6_fill_node(arg->net,
2597                      arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2598                      NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2599                      prefix, 0, NLM_F_MULTI);
2600 }
2601
2602 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh)
2603 {
2604         struct net *net = sock_net(in_skb->sk);
2605         struct nlattr *tb[RTA_MAX+1];
2606         struct rt6_info *rt;
2607         struct sk_buff *skb;
2608         struct rtmsg *rtm;
2609         struct flowi6 fl6;
2610         int err, iif = 0, oif = 0;
2611
2612         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2613         if (err < 0)
2614                 goto errout;
2615
2616         err = -EINVAL;
2617         memset(&fl6, 0, sizeof(fl6));
2618
2619         if (tb[RTA_SRC]) {
2620                 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2621                         goto errout;
2622
2623                 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2624         }
2625
2626         if (tb[RTA_DST]) {
2627                 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2628                         goto errout;
2629
2630                 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2631         }
2632
2633         if (tb[RTA_IIF])
2634                 iif = nla_get_u32(tb[RTA_IIF]);
2635
2636         if (tb[RTA_OIF])
2637                 oif = nla_get_u32(tb[RTA_OIF]);
2638
2639         if (iif) {
2640                 struct net_device *dev;
2641                 int flags = 0;
2642
2643                 dev = __dev_get_by_index(net, iif);
2644                 if (!dev) {
2645                         err = -ENODEV;
2646                         goto errout;
2647                 }
2648
2649                 fl6.flowi6_iif = iif;
2650
2651                 if (!ipv6_addr_any(&fl6.saddr))
2652                         flags |= RT6_LOOKUP_F_HAS_SADDR;
2653
2654                 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2655                                                                flags);
2656         } else {
2657                 fl6.flowi6_oif = oif;
2658
2659                 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2660         }
2661
2662         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2663         if (!skb) {
2664                 ip6_rt_put(rt);
2665                 err = -ENOBUFS;
2666                 goto errout;
2667         }
2668
2669         /* Reserve room for dummy headers, this skb can pass
2670            through good chunk of routing engine.
2671          */
2672         skb_reset_mac_header(skb);
2673         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2674
2675         skb_dst_set(skb, &rt->dst);
2676
2677         err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2678                             RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2679                             nlh->nlmsg_seq, 0, 0, 0);
2680         if (err < 0) {
2681                 kfree_skb(skb);
2682                 goto errout;
2683         }
2684
2685         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2686 errout:
2687         return err;
2688 }
2689
2690 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2691 {
2692         struct sk_buff *skb;
2693         struct net *net = info->nl_net;
2694         u32 seq;
2695         int err;
2696
2697         err = -ENOBUFS;
2698         seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2699
2700         skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2701         if (!skb)
2702                 goto errout;
2703
2704         err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2705                                 event, info->portid, seq, 0, 0, 0);
2706         if (err < 0) {
2707                 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2708                 WARN_ON(err == -EMSGSIZE);
2709                 kfree_skb(skb);
2710                 goto errout;
2711         }
2712         rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2713                     info->nlh, gfp_any());
2714         return;
2715 errout:
2716         if (err < 0)
2717                 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2718 }
2719
2720 static int ip6_route_dev_notify(struct notifier_block *this,
2721                                 unsigned long event, void *data)
2722 {
2723         struct net_device *dev = (struct net_device *)data;
2724         struct net *net = dev_net(dev);
2725
2726         if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2727                 net->ipv6.ip6_null_entry->dst.dev = dev;
2728                 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2729 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2730                 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2731                 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2732                 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2733                 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2734 #endif
2735         }
2736
2737         return NOTIFY_OK;
2738 }
2739
2740 /*
2741  *      /proc
2742  */
2743
2744 #ifdef CONFIG_PROC_FS
2745
2746 struct rt6_proc_arg
2747 {
2748         char *buffer;
2749         int offset;
2750         int length;
2751         int skip;
2752         int len;
2753 };
2754
2755 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2756 {
2757         struct seq_file *m = p_arg;
2758
2759         seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2760
2761 #ifdef CONFIG_IPV6_SUBTREES
2762         seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2763 #else
2764         seq_puts(m, "00000000000000000000000000000000 00 ");
2765 #endif
2766         if (rt->rt6i_flags & RTF_GATEWAY) {
2767                 seq_printf(m, "%pi6", &rt->rt6i_gateway);
2768         } else {
2769                 seq_puts(m, "00000000000000000000000000000000");
2770         }
2771         seq_printf(m, " %08x %08x %08x %08x %8s\n",
2772                    rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2773                    rt->dst.__use, rt->rt6i_flags,
2774                    rt->dst.dev ? rt->dst.dev->name : "");
2775         return 0;
2776 }
2777
2778 static int ipv6_route_show(struct seq_file *m, void *v)
2779 {
2780         struct net *net = (struct net *)m->private;
2781         fib6_clean_all_ro(net, rt6_info_route, 0, m);
2782         return 0;
2783 }
2784
2785 static int ipv6_route_open(struct inode *inode, struct file *file)
2786 {
2787         return single_open_net(inode, file, ipv6_route_show);
2788 }
2789
2790 static const struct file_operations ipv6_route_proc_fops = {
2791         .owner          = THIS_MODULE,
2792         .open           = ipv6_route_open,
2793         .read           = seq_read,
2794         .llseek         = seq_lseek,
2795         .release        = single_release_net,
2796 };
2797
2798 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2799 {
2800         struct net *net = (struct net *)seq->private;
2801         seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2802                    net->ipv6.rt6_stats->fib_nodes,
2803                    net->ipv6.rt6_stats->fib_route_nodes,
2804                    net->ipv6.rt6_stats->fib_rt_alloc,
2805                    net->ipv6.rt6_stats->fib_rt_entries,
2806                    net->ipv6.rt6_stats->fib_rt_cache,
2807                    dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2808                    net->ipv6.rt6_stats->fib_discarded_routes);
2809
2810         return 0;
2811 }
2812
2813 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2814 {
2815         return single_open_net(inode, file, rt6_stats_seq_show);
2816 }
2817
2818 static const struct file_operations rt6_stats_seq_fops = {
2819         .owner   = THIS_MODULE,
2820         .open    = rt6_stats_seq_open,
2821         .read    = seq_read,
2822         .llseek  = seq_lseek,
2823         .release = single_release_net,
2824 };
2825 #endif  /* CONFIG_PROC_FS */
2826
2827 #ifdef CONFIG_SYSCTL
2828
2829 static
2830 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2831                               void __user *buffer, size_t *lenp, loff_t *ppos)
2832 {
2833         struct net *net;
2834         int delay;
2835         if (!write)
2836                 return -EINVAL;
2837
2838         net = (struct net *)ctl->extra1;
2839         delay = net->ipv6.sysctl.flush_delay;
2840         proc_dointvec(ctl, write, buffer, lenp, ppos);
2841         fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2842         return 0;
2843 }
2844
2845 ctl_table ipv6_route_table_template[] = {
2846         {
2847                 .procname       =       "flush",
2848                 .data           =       &init_net.ipv6.sysctl.flush_delay,
2849                 .maxlen         =       sizeof(int),
2850                 .mode           =       0200,
2851                 .proc_handler   =       ipv6_sysctl_rtcache_flush
2852         },
2853         {
2854                 .procname       =       "gc_thresh",
2855                 .data           =       &ip6_dst_ops_template.gc_thresh,
2856                 .maxlen         =       sizeof(int),
2857                 .mode           =       0644,
2858                 .proc_handler   =       proc_dointvec,
2859         },
2860         {
2861                 .procname       =       "max_size",
2862                 .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
2863                 .maxlen         =       sizeof(int),
2864                 .mode           =       0644,
2865                 .proc_handler   =       proc_dointvec,
2866         },
2867         {
2868                 .procname       =       "gc_min_interval",
2869                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2870                 .maxlen         =       sizeof(int),
2871                 .mode           =       0644,
2872                 .proc_handler   =       proc_dointvec_jiffies,
2873         },
2874         {
2875                 .procname       =       "gc_timeout",
2876                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2877                 .maxlen         =       sizeof(int),
2878                 .mode           =       0644,
2879                 .proc_handler   =       proc_dointvec_jiffies,
2880         },
2881         {
2882                 .procname       =       "gc_interval",
2883                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2884                 .maxlen         =       sizeof(int),
2885                 .mode           =       0644,
2886                 .proc_handler   =       proc_dointvec_jiffies,
2887         },
2888         {
2889                 .procname       =       "gc_elasticity",
2890                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2891                 .maxlen         =       sizeof(int),
2892                 .mode           =       0644,
2893                 .proc_handler   =       proc_dointvec,
2894         },
2895         {
2896                 .procname       =       "mtu_expires",
2897                 .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2898                 .maxlen         =       sizeof(int),
2899                 .mode           =       0644,
2900                 .proc_handler   =       proc_dointvec_jiffies,
2901         },
2902         {
2903                 .procname       =       "min_adv_mss",
2904                 .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2905                 .maxlen         =       sizeof(int),
2906                 .mode           =       0644,
2907                 .proc_handler   =       proc_dointvec,
2908         },
2909         {
2910                 .procname       =       "gc_min_interval_ms",
2911                 .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2912                 .maxlen         =       sizeof(int),
2913                 .mode           =       0644,
2914                 .proc_handler   =       proc_dointvec_ms_jiffies,
2915         },
2916         { }
2917 };
2918
2919 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2920 {
2921         struct ctl_table *table;
2922
2923         table = kmemdup(ipv6_route_table_template,
2924                         sizeof(ipv6_route_table_template),
2925                         GFP_KERNEL);
2926
2927         if (table) {
2928                 table[0].data = &net->ipv6.sysctl.flush_delay;
2929                 table[0].extra1 = net;
2930                 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2931                 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2932                 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2933                 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2934                 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2935                 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2936                 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2937                 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2938                 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2939
2940                 /* Don't export sysctls to unprivileged users */
2941                 if (net->user_ns != &init_user_ns)
2942                         table[0].procname = NULL;
2943         }
2944
2945         return table;
2946 }
2947 #endif
2948
2949 static int __net_init ip6_route_net_init(struct net *net)
2950 {
2951         int ret = -ENOMEM;
2952
2953         memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2954                sizeof(net->ipv6.ip6_dst_ops));
2955
2956         if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2957                 goto out_ip6_dst_ops;
2958
2959         net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2960                                            sizeof(*net->ipv6.ip6_null_entry),
2961                                            GFP_KERNEL);
2962         if (!net->ipv6.ip6_null_entry)
2963                 goto out_ip6_dst_entries;
2964         net->ipv6.ip6_null_entry->dst.path =
2965                 (struct dst_entry *)net->ipv6.ip6_null_entry;
2966         net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2967         dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2968                          ip6_template_metrics, true);
2969
2970 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2971         net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2972                                                sizeof(*net->ipv6.ip6_prohibit_entry),
2973                                                GFP_KERNEL);
2974         if (!net->ipv6.ip6_prohibit_entry)
2975                 goto out_ip6_null_entry;
2976         net->ipv6.ip6_prohibit_entry->dst.path =
2977                 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2978         net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2979         dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
2980                          ip6_template_metrics, true);
2981
2982         net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2983                                                sizeof(*net->ipv6.ip6_blk_hole_entry),
2984                                                GFP_KERNEL);
2985         if (!net->ipv6.ip6_blk_hole_entry)
2986                 goto out_ip6_prohibit_entry;
2987         net->ipv6.ip6_blk_hole_entry->dst.path =
2988                 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2989         net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2990         dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
2991                          ip6_template_metrics, true);
2992 #endif
2993
2994         net->ipv6.sysctl.flush_delay = 0;
2995         net->ipv6.sysctl.ip6_rt_max_size = 4096;
2996         net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2997         net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2998         net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2999         net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3000         net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3001         net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3002
3003         net->ipv6.ip6_rt_gc_expire = 30*HZ;
3004
3005         ret = 0;
3006 out:
3007         return ret;
3008
3009 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3010 out_ip6_prohibit_entry:
3011         kfree(net->ipv6.ip6_prohibit_entry);
3012 out_ip6_null_entry:
3013         kfree(net->ipv6.ip6_null_entry);
3014 #endif
3015 out_ip6_dst_entries:
3016         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3017 out_ip6_dst_ops:
3018         goto out;
3019 }
3020
3021 static void __net_exit ip6_route_net_exit(struct net *net)
3022 {
3023         kfree(net->ipv6.ip6_null_entry);
3024 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3025         kfree(net->ipv6.ip6_prohibit_entry);
3026         kfree(net->ipv6.ip6_blk_hole_entry);
3027 #endif
3028         dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3029 }
3030
3031 static int __net_init ip6_route_net_init_late(struct net *net)
3032 {
3033 #ifdef CONFIG_PROC_FS
3034         proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3035         proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3036 #endif
3037         return 0;
3038 }
3039
3040 static void __net_exit ip6_route_net_exit_late(struct net *net)
3041 {
3042 #ifdef CONFIG_PROC_FS
3043         remove_proc_entry("ipv6_route", net->proc_net);
3044         remove_proc_entry("rt6_stats", net->proc_net);
3045 #endif
3046 }
3047
3048 static struct pernet_operations ip6_route_net_ops = {
3049         .init = ip6_route_net_init,
3050         .exit = ip6_route_net_exit,
3051 };
3052
3053 static int __net_init ipv6_inetpeer_init(struct net *net)
3054 {
3055         struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3056
3057         if (!bp)
3058                 return -ENOMEM;
3059         inet_peer_base_init(bp);
3060         net->ipv6.peers = bp;
3061         return 0;
3062 }
3063
3064 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3065 {
3066         struct inet_peer_base *bp = net->ipv6.peers;
3067
3068         net->ipv6.peers = NULL;
3069         inetpeer_invalidate_tree(bp);
3070         kfree(bp);
3071 }
3072
3073 static struct pernet_operations ipv6_inetpeer_ops = {
3074         .init   =       ipv6_inetpeer_init,
3075         .exit   =       ipv6_inetpeer_exit,
3076 };
3077
3078 static struct pernet_operations ip6_route_net_late_ops = {
3079         .init = ip6_route_net_init_late,
3080         .exit = ip6_route_net_exit_late,
3081 };
3082
3083 static struct notifier_block ip6_route_dev_notifier = {
3084         .notifier_call = ip6_route_dev_notify,
3085         .priority = 0,
3086 };
3087
3088 int __init ip6_route_init(void)
3089 {
3090         int ret;
3091
3092         ret = -ENOMEM;
3093         ip6_dst_ops_template.kmem_cachep =
3094                 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3095                                   SLAB_HWCACHE_ALIGN, NULL);
3096         if (!ip6_dst_ops_template.kmem_cachep)
3097                 goto out;
3098
3099         ret = dst_entries_init(&ip6_dst_blackhole_ops);
3100         if (ret)
3101                 goto out_kmem_cache;
3102
3103         ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3104         if (ret)
3105                 goto out_dst_entries;
3106
3107         ret = register_pernet_subsys(&ip6_route_net_ops);
3108         if (ret)
3109                 goto out_register_inetpeer;
3110
3111         ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3112
3113         /* Registering of the loopback is done before this portion of code,
3114          * the loopback reference in rt6_info will not be taken, do it
3115          * manually for init_net */
3116         init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3117         init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3118   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3119         init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3120         init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3121         init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3122         init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3123   #endif
3124         ret = fib6_init();
3125         if (ret)
3126                 goto out_register_subsys;
3127
3128         ret = xfrm6_init();
3129         if (ret)
3130                 goto out_fib6_init;
3131
3132         ret = fib6_rules_init();
3133         if (ret)
3134                 goto xfrm6_init;
3135
3136         ret = register_pernet_subsys(&ip6_route_net_late_ops);
3137         if (ret)
3138                 goto fib6_rules_init;
3139
3140         ret = -ENOBUFS;
3141         if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3142             __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3143             __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3144                 goto out_register_late_subsys;
3145
3146         ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3147         if (ret)
3148                 goto out_register_late_subsys;
3149
3150 out:
3151         return ret;
3152
3153 out_register_late_subsys:
3154         unregister_pernet_subsys(&ip6_route_net_late_ops);
3155 fib6_rules_init:
3156         fib6_rules_cleanup();
3157 xfrm6_init:
3158         xfrm6_fini();
3159 out_fib6_init:
3160         fib6_gc_cleanup();
3161 out_register_subsys:
3162         unregister_pernet_subsys(&ip6_route_net_ops);
3163 out_register_inetpeer:
3164         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3165 out_dst_entries:
3166         dst_entries_destroy(&ip6_dst_blackhole_ops);
3167 out_kmem_cache:
3168         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3169         goto out;
3170 }
3171
3172 void ip6_route_cleanup(void)
3173 {
3174         unregister_netdevice_notifier(&ip6_route_dev_notifier);
3175         unregister_pernet_subsys(&ip6_route_net_late_ops);
3176         fib6_rules_cleanup();
3177         xfrm6_fini();
3178         fib6_gc_cleanup();
3179         unregister_pernet_subsys(&ipv6_inetpeer_ops);
3180         unregister_pernet_subsys(&ip6_route_net_ops);
3181         dst_entries_destroy(&ip6_dst_blackhole_ops);
3182         kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3183 }