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