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