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