kernel/net/ipv6/route.c

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