net/ipv6/route.c

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