}
        ndev = n->dev;
 
-       if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
+       if (ipv6_addr_is_multicast(&daddr6->sin6_addr)) {
                pr_info("multi-cast route %pI6 port %u, dev %s.\n",
                        daddr6->sin6_addr.s6_addr,
                        ntohs(daddr6->sin6_port), ndev->name);
 
        return __ipv6_addr_diff(a1, a2, sizeof(struct in6_addr));
 }
 
-u32 ipv6_select_ident(struct net *net, struct rt6_info *rt);
+u32 ipv6_select_ident(struct net *net,
+                     const struct in6_addr *daddr,
+                     const struct in6_addr *saddr);
 void ipv6_proxy_select_ident(struct net *net, struct sk_buff *skb);
 
 int ip6_dst_hoplimit(struct dst_entry *dst);
 
                        struct inet_peer *peer;
 
                        peer = inet_getpeer_v6(net->ipv6.peers,
-                                              &rt->rt6i_dst.addr, 1);
+                                              &fl6->daddr, 1);
                        res = inet_peer_xrlim_allow(peer, tmo);
                        if (peer)
                                inet_putpeer(peer);
 
                else
                        target = &hdr->daddr;
 
-               peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
+               peer = inet_getpeer_v6(net->ipv6.peers, &hdr->daddr, 1);
 
                /* Limit redirects both by destination (here)
                   and by source (inside ndisc_send_redirect)
        }
        mtu -= hlen + sizeof(struct frag_hdr);
 
-       frag_id = ipv6_select_ident(net, rt);
+       frag_id = ipv6_select_ident(net, &ipv6_hdr(skb)->daddr,
+                                   &ipv6_hdr(skb)->saddr);
 
        if (skb_has_frag_list(skb)) {
                int first_len = skb_pagelen(skb);
                        int odd, struct sk_buff *skb),
                        void *from, int length, int hh_len, int fragheaderlen,
                        int transhdrlen, int mtu, unsigned int flags,
-                       struct rt6_info *rt)
+                       const struct flowi6 *fl6)
 
 {
        struct sk_buff *skb;
        skb_shinfo(skb)->gso_size = (mtu - fragheaderlen -
                                     sizeof(struct frag_hdr)) & ~7;
        skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
-       skb_shinfo(skb)->ip6_frag_id = ipv6_select_ident(sock_net(sk), rt);
+       skb_shinfo(skb)->ip6_frag_id = ipv6_select_ident(sock_net(sk),
+                                                        &fl6->daddr,
+                                                        &fl6->saddr);
 
 append:
        return skb_append_datato_frags(sk, skb, getfrag, from,
            (sk->sk_type == SOCK_DGRAM)) {
                err = ip6_ufo_append_data(sk, queue, getfrag, from, length,
                                          hh_len, fragheaderlen,
-                                         transhdrlen, mtu, flags, rt);
+                                         transhdrlen, mtu, flags, fl6);
                if (err)
                        goto error;
                return 0;
 
                          "Redirect: destination is not a neighbour\n");
                goto release;
        }
-       peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
+       peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
        ret = inet_peer_xrlim_allow(peer, 1*HZ);
        if (peer)
                inet_putpeer(peer);
 
 #include <net/secure_seq.h>
 
 static u32 __ipv6_select_ident(struct net *net, u32 hashrnd,
-                              struct in6_addr *dst, struct in6_addr *src)
+                              const struct in6_addr *dst,
+                              const struct in6_addr *src)
 {
        u32 hash, id;
 
 }
 EXPORT_SYMBOL_GPL(ipv6_proxy_select_ident);
 
-u32 ipv6_select_ident(struct net *net, struct rt6_info *rt)
+u32 ipv6_select_ident(struct net *net,
+                     const struct in6_addr *daddr,
+                     const struct in6_addr *saddr)
 {
        static u32 ip6_idents_hashrnd __read_mostly;
        u32 id;
 
        net_get_random_once(&ip6_idents_hashrnd, sizeof(ip6_idents_hashrnd));
 
-       id = __ipv6_select_ident(net, ip6_idents_hashrnd, &rt->rt6i_dst.addr,
-                                &rt->rt6i_src.addr);
+       id = __ipv6_select_ident(net, ip6_idents_hashrnd, daddr, saddr);
        return htonl(id);
 }
 EXPORT_SYMBOL(ipv6_select_ident);
 
        rt = (struct rt6_info *) dst;
        if (tcp_death_row.sysctl_tw_recycle &&
            !tp->rx_opt.ts_recent_stamp &&
-           ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
+           ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr))
                tcp_fetch_timewait_stamp(sk, dst);
 
        icsk->icsk_ext_hdr_len = 0;
 
 
        /* From world but DNAT to loopback address? */
        if (local && skb->dev && !(skb->dev->flags & IFF_LOOPBACK) &&
-           ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_LOOPBACK) {
+           ipv6_addr_type(&cp->daddr.in6) & IPV6_ADDR_LOOPBACK) {
                IP_VS_DBG_RL_PKT(1, AF_INET6, pp, skb, 0,
                                 "ip_vs_nat_xmit_v6(): "
                                 "stopping DNAT to loopback address");
 
        /* From world but DNAT to loopback address? */
        if (local && skb->dev && !(skb->dev->flags & IFF_LOOPBACK) &&
-           ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_LOOPBACK) {
+           ipv6_addr_type(&cp->daddr.in6) & IPV6_ADDR_LOOPBACK) {
                IP_VS_DBG(1, "%s(): "
                          "stopping DNAT to loopback %pI6\n",
                          __func__, &cp->daddr.in6);
 
                rt = (struct rt6_info *)dst;
                t->dst = dst;
                t->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
-               pr_debug("rt6_dst:%pI6 rt6_src:%pI6\n", &rt->rt6i_dst.addr,
+               pr_debug("rt6_dst:%pI6/%d rt6_src:%pI6\n",
+                        &rt->rt6i_dst.addr, rt->rt6i_dst.plen,
                         &fl6->saddr);
        } else {
                t->dst = NULL;