(Anonymous) unions can help us to avoid ugly casts.
A common cast it the (struct rtable *)skb->dst one.
Defining an union like  :
union {
     struct dst_entry *dst;
     struct rtable *rtable;
};
permits to use skb->rtable in place.
Signed-off-by: Eric Dumazet <dada1@cosmosbay.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
        ktime_t                 tstamp;
        struct net_device       *dev;
 
-       struct  dst_entry       *dst;
+       union {
+               struct  dst_entry       *dst;
+               struct  rtable          *rtable;
+       };
        struct  sec_path        *sp;
 
        /*
 
 
 static inline int inet_iif(const struct sk_buff *skb)
 {
-       return ((struct rtable *)skb->dst)->rt_iif;
+       return skb->rtable->rt_iif;
 }
 
 #endif /* _INET_SOCK_H */
 
        }
        nf_bridge->mask ^= BRNF_NF_BRIDGE_PREROUTING;
 
-       skb->dst = (struct dst_entry *)&__fake_rtable;
-       dst_hold(skb->dst);
+       skb->rtable = &__fake_rtable;
+       dst_hold(&__fake_rtable.u.dst);
 
        skb->dev = nf_bridge->physindev;
        nf_bridge_push_encap_header(skb);
                        skb->pkt_type = PACKET_HOST;
                }
        } else {
-               skb->dst = (struct dst_entry *)&__fake_rtable;
-               dst_hold(skb->dst);
+               skb->rtable = &__fake_rtable;
+               dst_hold(&__fake_rtable.u.dst);
        }
 
        skb->dev = nf_bridge->physindev;
                                   const struct net_device *out,
                                   int (*okfn)(struct sk_buff *))
 {
-       if (skb->dst == (struct dst_entry *)&__fake_rtable) {
-               dst_release(skb->dst);
-               skb->dst = NULL;
+       if (skb->rtable == &__fake_rtable) {
+               dst_release(&__fake_rtable.u.dst);
+               skb->rtable = NULL;
        }
 
        return NF_ACCEPT;
 
                                           struct sk_buff *skb)
 {
        struct rtable *rt;
-       struct flowi fl = { .oif = ((struct rtable *)skb->dst)->rt_iif,
+       struct flowi fl = { .oif = skb->rtable->rt_iif,
                            .nl_u = { .ip4_u =
                                      { .daddr = ip_hdr(skb)->saddr,
                                        .saddr = ip_hdr(skb)->daddr,
        if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
                return;
 
-       if (((struct rtable *)rxskb->dst)->rt_type != RTN_LOCAL)
+       if (rxskb->rtable->rt_type != RTN_LOCAL)
                return;
 
        dst = dccp_v4_route_skb(dccp_v4_ctl_socket->sk, rxskb);
        struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
 
        /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
-       if (((struct rtable *)skb->dst)->rt_flags &
-           (RTCF_BROADCAST | RTCF_MULTICAST))
+       if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
                return 0;       /* discard, don't send a reset here */
 
        if (dccp_bad_service_code(sk, service)) {
 
                return 1;
        }
 
-       paddr = ((struct rtable*)skb->dst)->rt_gateway;
+       paddr = skb->rtable->rt_gateway;
 
        if (arp_set_predefined(inet_addr_type(&init_net, paddr), haddr, paddr, dev))
                return 0;
        if (arp->ar_op == htons(ARPOP_REQUEST) &&
            ip_route_input(skb, tip, sip, 0, dev) == 0) {
 
-               rt = (struct rtable*)skb->dst;
+               rt = skb->rtable;
                addr_type = rt->rt_type;
 
                if (addr_type == RTN_LOCAL) {
 
 static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
 {
        struct ipcm_cookie ipc;
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct net *net = rt->u.dst.dev->nd_net;
        struct sock *sk = icmp_sk(net);
        struct inet_sock *inet = inet_sk(sk);
        struct iphdr *iph;
        int room;
        struct icmp_bxm icmp_param;
-       struct rtable *rt = (struct rtable *)skb_in->dst;
+       struct rtable *rt = skb_in->rtable;
        struct ipcm_cookie ipc;
        __be32 saddr;
        u8  tos;
                                             RT_TOS(tos), rt2->u.dst.dev);
 
                        dst_release(&rt2->u.dst);
-                       rt2 = (struct rtable *)skb_in->dst;
+                       rt2 = skb_in->rtable;
                        skb_in->dst = odst;
                }
 
 
 static void icmp_address_reply(struct sk_buff *skb)
 {
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct net_device *dev = skb->dev;
        struct in_device *in_dev;
        struct in_ifaddr *ifa;
 int icmp_rcv(struct sk_buff *skb)
 {
        struct icmphdr *icmph;
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
 
        if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
                int nh;
 
        case IGMPV2_HOST_MEMBERSHIP_REPORT:
        case IGMPV3_HOST_MEMBERSHIP_REPORT:
                /* Is it our report looped back? */
-               if (((struct rtable*)skb->dst)->fl.iif == 0)
+               if (skb->rtable->fl.iif == 0)
                        break;
                /* don't rely on MC router hearing unicast reports */
                if (skb->pkt_type == PACKET_MULTICAST ||
 
        if (!xfrm4_route_forward(skb))
                goto drop;
 
-       rt = (struct rtable*)skb->dst;
+       rt = skb->rtable;
 
        if (opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
                goto sr_failed;
 
 #ifdef CONFIG_NET_IPGRE_BROADCAST
                if (ipv4_is_multicast(iph->daddr)) {
                        /* Looped back packet, drop it! */
-                       if (((struct rtable*)skb->dst)->fl.iif == 0)
+                       if (skb->rtable->fl.iif == 0)
                                goto drop;
                        tunnel->stat.multicast++;
                        skb->pkt_type = PACKET_BROADCAST;
                }
 
                if (skb->protocol == htons(ETH_P_IP)) {
-                       rt = (struct rtable*)skb->dst;
+                       rt = skb->rtable;
                        if ((dst = rt->rt_gateway) == 0)
                                goto tx_error_icmp;
                }
 
        if (iph->ihl > 5 && ip_rcv_options(skb))
                goto drop;
 
-       rt = (struct rtable*)skb->dst;
+       rt = skb->rtable;
        if (rt->rt_type == RTN_MULTICAST)
                IP_INC_STATS_BH(IPSTATS_MIB_INMCASTPKTS);
        else if (rt->rt_type == RTN_BROADCAST)
 
        sptr = skb_network_header(skb);
        dptr = dopt->__data;
 
-       daddr = ((struct rtable*)skb->dst)->rt_spec_dst;
+       daddr = skb->rtable->rt_spec_dst;
 
        if (sopt->rr) {
                optlen  = sptr[sopt->rr+1];
        unsigned char * optptr;
        int optlen;
        unsigned char * pp_ptr = NULL;
-       struct rtable *rt = skb ? (struct rtable*)skb->dst : NULL;
+       struct rtable *rt = skb ? skb->rtable : NULL;
 
        if (!opt) {
                opt = &(IPCB(skb)->opt);
 {
        struct   ip_options * opt       = &(IPCB(skb)->opt);
        unsigned char * optptr;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        unsigned char *raw = skb_network_header(skb);
 
        if (opt->rr_needaddr) {
        __be32 nexthop;
        struct iphdr *iph = ip_hdr(skb);
        unsigned char *optptr = skb_network_header(skb) + opt->srr;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct rtable *rt2;
        int err;
 
                }
                memcpy(&nexthop, &optptr[srrptr-1], 4);
 
-               rt = (struct rtable*)skb->dst;
-               skb->dst = NULL;
+               rt = skb->rtable;
+               skb->rtable = NULL;
                err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
-               rt2 = (struct rtable*)skb->dst;
+               rt2 = skb->rtable;
                if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
                        ip_rt_put(rt2);
-                       skb->dst = &rt->u.dst;
+                       skb->rtable = rt;
                        return -EINVAL;
                }
                ip_rt_put(rt);
 
                          __be32 saddr, __be32 daddr, struct ip_options *opt)
 {
        struct inet_sock *inet = inet_sk(sk);
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct iphdr *iph;
 
        /* Build the IP header. */
 int ip_mc_output(struct sk_buff *skb)
 {
        struct sock *sk = skb->sk;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct net_device *dev = rt->u.dst.dev;
 
        /*
        /* Skip all of this if the packet is already routed,
         * f.e. by something like SCTP.
         */
-       rt = (struct rtable *) skb->dst;
+       rt = skb->rtable;
        if (rt != NULL)
                goto packet_routed;
 
        unsigned int mtu, hlen, left, len, ll_rs, pad;
        int offset;
        __be16 not_last_frag;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        int err = 0;
 
        dev = rt->u.dst.dev;
        } replyopts;
        struct ipcm_cookie ipc;
        __be32 daddr;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
 
        if (ip_options_echo(&replyopts.opt, skb))
                return;
 
 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
 {
        struct in_pktinfo info;
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
 
        info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
        if (rt) {
 
 
        if (!dst) {
                /* NBMA tunnel */
-               if ((rt = (struct rtable*)skb->dst) == NULL) {
+               if ((rt = skb->rtable) == NULL) {
                        tunnel->stat.tx_fifo_errors++;
                        goto tx_error;
                }
 
        if (vif_table[vif].dev != skb->dev) {
                int true_vifi;
 
-               if (((struct rtable*)skb->dst)->fl.iif == 0) {
+               if (skb->rtable->fl.iif == 0) {
                        /* It is our own packet, looped back.
                           Very complicated situation...
 
 int ip_mr_input(struct sk_buff *skb)
 {
        struct mfc_cache *cache;
-       int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
+       int local = skb->rtable->rt_flags&RTCF_LOCAL;
 
        /* Packet is looped back after forward, it should not be
           forwarded second time, but still can be delivered locally.
 {
        int err;
        struct mfc_cache *cache;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
 
        read_lock(&mrt_lock);
        cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
 
                return NF_ACCEPT;
 
        mr = targinfo;
-       rt = (struct rtable *)skb->dst;
+       rt = skb->rtable;
        newsrc = inet_select_addr(out, rt->rt_gateway, RT_SCOPE_UNIVERSE);
        if (!newsrc) {
                printk("MASQUERADE: %s ate my IP address\n", out->name);
 
                         const char *rep_buffer,
                         unsigned int rep_len)
 {
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct iphdr *iph;
        struct tcphdr *tcph;
        int oldlen, datalen;
                         const char *rep_buffer,
                         unsigned int rep_len)
 {
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct iphdr *iph;
        struct udphdr *udph;
        int datalen, oldlen;
 
 
 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
 {
-       struct rtable *rt = (struct rtable*)dst;
+       struct rtable *rt = (struct rtable *)dst;
        struct dst_entry *ret = dst;
 
        if (rt) {
 
 void ip_rt_send_redirect(struct sk_buff *skb)
 {
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
 
        if (!in_dev)
 
 static int ip_error(struct sk_buff *skb)
 {
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        unsigned long now;
        int code;
 
 
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
 
-       rt = (struct rtable *) skb->dst;
+       rt = skb->rtable;
        if (rt)
                dst_set_expires(&rt->u.dst, 0);
 }
 
        in_dev_put(in_dev);
        hash = rt_hash(daddr, saddr, dev->ifindex);
-       return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst);
+       return rt_intern_hash(hash, rth, &skb->rtable);
 
 e_nobufs:
        in_dev_put(in_dev);
 
        /* put it into the cache */
        hash = rt_hash(daddr, saddr, fl->iif);
-       return rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
+       return rt_intern_hash(hash, rth, &skb->rtable);
 }
 
 /*
        }
        rth->rt_type    = res.type;
        hash = rt_hash(daddr, saddr, fl.iif);
-       err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
+       err = rt_intern_hash(hash, rth, &skb->rtable);
        goto done;
 
 no_route:
                        dst_use(&rth->u.dst, jiffies);
                        RT_CACHE_STAT_INC(in_hit);
                        rcu_read_unlock();
-                       skb->dst = (struct dst_entry*)rth;
+                       skb->rtable = rth;
                        return 0;
                }
                RT_CACHE_STAT_INC(in_hlist_search);
 static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                        int nowait, unsigned int flags)
 {
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct rtmsg *r;
        struct nlmsghdr *nlh;
        long expires;
                err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
                local_bh_enable();
 
-               rt = (struct rtable*) skb->dst;
+               rt = skb->rtable;
                if (err == 0 && rt->u.dst.error)
                        err = -rt->u.dst.error;
        } else {
        if (err)
                goto errout_free;
 
-       skb->dst = &rt->u.dst;
+       skb->rtable = rt;
        if (rtm->rtm_flags & RTM_F_NOTIFY)
                rt->rt_flags |= RTCF_NOTIFY;
 
 
        if (th->rst)
                return;
 
-       if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
+       if (skb->rtable->rt_type != RTN_LOCAL)
                return;
 
        /* Swap the send and the receive. */
 #endif
 
        /* Never answer to SYNs send to broadcast or multicast */
-       if (((struct rtable *)skb->dst)->rt_flags &
-           (RTCF_BROADCAST | RTCF_MULTICAST))
+       if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
                goto drop;
 
        /* TW buckets are converted to open requests without
 
        struct sock *sk;
        struct udphdr *uh = udp_hdr(skb);
        unsigned short ulen;
-       struct rtable *rt = (struct rtable*)skb->dst;
+       struct rtable *rt = skb->rtable;
        __be32 saddr = ip_hdr(skb)->saddr;
        __be32 daddr = ip_hdr(skb)->daddr;
 
 
 {
        struct nf_conntrack_expect *exp;
        struct iphdr *iph = ip_hdr(skb);
-       struct rtable *rt = (struct rtable *)skb->dst;
+       struct rtable *rt = skb->rtable;
        struct in_device *in_dev;
        __be32 mask = 0;
 
 
 
 META_COLLECTOR(int_rtiif)
 {
-       if (unlikely(skb->dst == NULL))
+       if (unlikely(skb->rtable == NULL))
                *err = -1;
        else
-               dst->value = ((struct rtable*) skb->dst)->fl.iif;
+               dst->value = skb->rtable->fl.iif;
 }
 
 /**************************************************************************
 
                return 0;
 
        /* Is this a broadcast address? */
-       if (skb && ((struct rtable *)skb->dst)->rt_flags & RTCF_BROADCAST)
+       if (skb && skb->rtable->rt_flags & RTCF_BROADCAST)
                return 0;
 
        return 1;
 /* What interface did this skb arrive on? */
 static int sctp_v4_skb_iif(const struct sk_buff *skb)
 {
-       return ((struct rtable *)skb->dst)->rt_iif;
+       return skb->rtable->rt_iif;
 }
 
 /* Was this packet marked by Explicit Congestion Notification? */
        SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, "
                          "src:%u.%u.%u.%u, dst:%u.%u.%u.%u\n",
                          __FUNCTION__, skb, skb->len,
-                         NIPQUAD(((struct rtable *)skb->dst)->rt_src),
-                         NIPQUAD(((struct rtable *)skb->dst)->rt_dst));
+                         NIPQUAD(skb->rtable->rt_src),
+                         NIPQUAD(skb->rtable->rt_dst));
 
        SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
        return ip_queue_xmit(skb, ipfragok);