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