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