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