skb = alloc_skb(len, GFP_ATOMIC);
        if (skb) {
                skb_reset_mac_header(skb);
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
                skb->protocol = __constant_htons(ETH_P_AOE);
                skb->priority = 0;
                skb->next = skb->prev = NULL;
 
 {
        rq->offload_pkts++;
        skb_reset_mac_header(skb);
-       skb->nh.raw = skb->h.raw = skb->data;
+       skb_reset_network_header(skb);
+       skb->h.raw = skb->data;
 
        if (rq->polling) {
                rx_gather[gather_idx++] = skb;
 
        }
 
        skb->protocol = ax25_type_trans(skb, dev);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        dev->hard_header(skb, dev, ETH_P_BPQ, bpq->dest_addr, NULL, 0);
        bpq->stats.tx_packets++;
        bpq->stats.tx_bytes+=skb->len;
 
                        break;
                skb_reserve(nskb, 32);
                skb_set_mac_header(nskb, -ETH_HLEN);
-               nskb->nh.raw = nskb->data;
+               skb_reset_network_header(nskb);
                iph = nskb->nh.iph;
                memcpy(nskb->data, skb->nh.raw, doffset);
                if (skb_copy_bits(skb,
 
 
        /* Reserve space for headers. */
        skb_reserve(skb, dev->hard_header_len);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        skb->dev = dev;
 
        memcpy(ph, &hdr, sizeof(struct pppoe_hdr));
        skb2->protocol = __constant_htons(ETH_P_PPP_SES);
 
-       skb2->nh.raw = skb2->data;
+       skb_reset_network_header(skb2);
 
        skb2->dev = dev;
 
 
        skb_put(skb, sizeof(struct cisco_packet));
        skb->priority = TC_PRIO_CONTROL;
        skb->dev = dev;
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        dev_queue_xmit(skb);
 }
 
        skb_put(skb, i);
        skb->priority = TC_PRIO_CONTROL;
        skb->dev = dev;
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        dev_queue_xmit(skb);
 }
 
             skb->protocol = lmc_proto_type(sc, skb);
             skb->protocol = htons(ETH_P_WAN_PPP);
             skb_reset_mac_header(skb);
-//            skb->nh.raw = skb->data;
+            /* skb_reset_network_header(skb); */
             skb->dev = dev;
             lmc_proto_netif(sc, skb);
 
             
             nsb->protocol = lmc_proto_type(sc, skb);
             skb_reset_mac_header(nsb);
-//            nsb->nh.raw = nsb->data;
+            /* skb_reset_network_header(nsb); */
             nsb->dev = dev;
             lmc_proto_netif(sc, nsb);
         }
 
                skb2->dev = dev;
                skb2->protocol = __constant_htons(ETH_P_802_3);
                skb_reset_mac_header(skb2);
-               skb2->nh.raw = skb2->data;
-               /* skb2->nh.raw = skb2->data + ETH_HLEN; */
+               skb_reset_network_header(skb2);
+               /* skb2->nh.raw += ETH_HLEN; */
                dev_queue_xmit(skb2);
        }
 
 
 
        skb->dev = dev;
        skb_reset_mac_header(skb);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        dev_queue_xmit(skb);
 }
 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
 
 
        skb->dev = dev;
        skb_reset_mac_header(skb);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        dev_queue_xmit(skb);
 
        return 0;
 
        skb->tail += len;
 }
 
+static inline void skb_reset_network_header(struct sk_buff *skb)
+{
+       skb->nh.raw = skb->data;
+}
+
 static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
 {
        return skb->mac.raw;
 
        struct llc_pdu_un *pdu;
 
        skb_push(skb, hlen);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        pdu = llc_pdu_un_hdr(skb);
        pdu->dsap = dsap;
        pdu->ssap = ssap;
 
        int hash;
        struct aarp_entry *a;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /* Check for LocalTalk first */
        if (dev->type == ARPHRD_LOCALTLK) {
 
        skb_push(new_skb, eg->ctrl_info.DH_length);     /* add MAC header */
        memcpy(new_skb->data, eg->ctrl_info.DLL_header, eg->ctrl_info.DH_length);
        new_skb->protocol = eth_type_trans(new_skb, dev);
-       new_skb->nh.raw = new_skb->data;
+       skb_reset_network_header(new_skb);
 
        eg->latest_ip_addr = new_skb->nh.iph->saddr;
        eg->packets_rcvd++;
 
                goto out;
        }
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /* Add the PID if one is not supplied by the user in the skb */
        if (!ax25->pidincl) {
 
        if ((skb = alloc_skb(2, GFP_ATOMIC)) == NULL)
                return;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        p = skb_put(skb, 2);
 
        *p++ = cmd;
 
                                        skb_reserve(skbn, AX25_MAX_HEADER_LEN);
 
                                        skbn->dev   = ax25->ax25_dev->dev;
+                                       skb_reset_network_header(skbn);
                                        skbn->h.raw = skbn->data;
-                                       skbn->nh.raw = skbn->data;
 
                                        /* Copy data from the fragments */
                                        while ((skbo = skb_dequeue(&ax25->frag_queue)) != NULL) {
 
                skb_pull(skb, 1);       /* Remove PID */
                skb_reset_mac_header(skb);
-               skb->nh.raw   = skb->data;
+               skb_reset_network_header(skb);
                skb->dev      = ax25->ax25_dev->dev;
                skb->pkt_type = PACKET_HOST;
                skb->protocol = htons(ETH_P_IP);
                case AX25_P_IP:
                        skb_pull(skb,2);                /* drop PID/CTRL */
                        skb->h.raw    = skb->data;
-                       skb->nh.raw   = skb->data;
+                       skb_reset_network_header(skb);
                        skb->dev      = dev;
                        skb->pkt_type = PACKET_HOST;
                        skb->protocol = htons(ETH_P_IP);
                case AX25_P_ARP:
                        skb_pull(skb,2);
                        skb->h.raw    = skb->data;
-                       skb->nh.raw   = skb->data;
+                       skb_reset_network_header(skb);
                        skb->dev      = dev;
                        skb->pkt_type = PACKET_HOST;
                        skb->protocol = htons(ETH_P_ARP);
 
                        src_c = *(ax25_address *)(bp + 8);
 
                        skb_pull(ourskb, AX25_HEADER_LEN - 1);  /* Keep PID */
-                       ourskb->nh.raw = ourskb->data;
+                       skb_reset_network_header(ourskb);
 
                        ax25=ax25_send_frame(
                            ourskb,
 
        if (skb == NULL)
                return;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        if (ax25->modulus == AX25_MODULUS) {
                frame = skb_push(skb, 1);
 
 
        skb_reserve(skb, ax25->ax25_dev->dev->hard_header_len);
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /* Assume a response - address structure for DTE */
        if (ax25->modulus == AX25_MODULUS) {
                return; /* Next SABM will get DM'd */
 
        skb_reserve(skb, dev->hard_header_len);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        ax25_digi_invert(digi, &retdigi);
 
 
                                        printk(KERN_CRIT "protocol %04x is "
                                               "buggy, dev %s\n",
                                               skb2->protocol, dev->name);
-                               skb2->nh.raw = skb2->data;
+                               skb_reset_network_header(skb2);
                        }
 
                        skb2->h.raw = skb2->nh.raw;
 
        __get_cpu_var(netdev_rx_stat).total++;
 
-       skb->h.raw = skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
+       skb->h.raw = skb->data;
        skb->mac_len = skb->nh.raw - skb->mac.raw;
 
        pt_prev = NULL;
 
                                 (2 * sizeof(u32)))))
                return;
 
-       skb->h.raw = skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
+       skb->h.raw = skb->data;
        arp = skb->nh.arph;
 
        if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
        if (!send_skb)
                return;
 
-       send_skb->nh.raw = send_skb->data;
+       skb_reset_network_header(send_skb);
        arp = (struct arphdr *) skb_put(send_skb, size);
        send_skb->dev = skb->dev;
        send_skb->protocol = htons(ETH_P_ARP);
 
        pktlen = (__le16 *)skb_push(skb,2);
        *pktlen = dn_htons(skb->len - 2);
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        dn_rt_finish_output(skb, dn_rt_all_rt_mcast, msg->id);
 }
        pktlen = (__le16 *)skb_push(skb, 2);
        *pktlen = dn_htons(skb->len - 2);
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        if (dn_am_i_a_router(dn, dn_db, ifa)) {
                struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
 
        lp->s_class  = 0;
        lp->pt       = 0;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 }
        sp->srcnode    = cb->src;
        sp->forward    = cb->hops & 0x3f;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 }
        sp->srcnode  = cb->src & dn_htons(0x03ff);
        sp->forward  = cb->hops & 0x3f;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 }
 
                flags = *skb->data;
        }
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /*
         * Weed out future version DECnet
 
                        goto out_unlock;
 
                skb_reserve(skb, LL_RESERVED_SPACE(dev));
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
 
                eb = (struct ec_cb *)&skb->cb;
 
 
                skb2->dev = dev;
                skb2->protocol = __constant_htons(ETH_P_802_3);
                skb_reset_mac_header(skb2);
-               skb2->nh.raw = skb2->data;
+               skb_reset_network_header(skb2);
                /* skb2->nh.raw = skb2->data + ETH_HLEN; */
                dev_queue_xmit(skb2);
        }
 
                return NULL;
 
        skb_reserve(skb, LL_RESERVED_SPACE(dev));
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
        skb->dev = dev;
        skb->protocol = htons(ETH_P_ARP);
 
        dst_release(skb2->dst);
        skb2->dst = NULL;
        skb_pull(skb2, skb->data - (u8*)eiph);
-       skb2->nh.raw = skb2->data;
+       skb_reset_network_header(skb2);
 
        /* Try to guess incoming interface */
        memset(&fl, 0, sizeof(fl));
 
                ip_copy_metadata(skb2, skb);
                skb_reserve(skb2, ll_rs);
                skb_put(skb2, len + hlen);
-               skb2->nh.raw = skb2->data;
+               skb_reset_network_header(skb2);
                skb2->h.raw = skb2->data + hlen;
 
                /*
                skb_put(skb,fragheaderlen + transhdrlen);
 
                /* initialize network header pointer */
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
 
                /* initialize protocol header pointer */
                skb->h.raw = skb->data + fragheaderlen;
 
        dst_release(skb2->dst);
        skb2->dst = NULL;
        skb_pull(skb2, skb->data - (u8*)eiph);
-       skb2->nh.raw = skb2->data;
+       skb_reset_network_header(skb2);
 
        /* Try to guess incoming interface */
        memset(&fl, 0, sizeof(fl));
                secpath_reset(skb);
 
                skb->mac.raw = skb->nh.raw;
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
                skb->protocol = htons(ETH_P_IP);
                skb->pkt_type = PACKET_HOST;
 
 
           through good chunk of routing engine.
         */
        skb_reset_mac_header(skb);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
        skb->nh.iph->protocol = IPPROTO_ICMP;
 
        old_mac = skb_mac_header(skb);
        skb_set_mac_header(skb, -skb->mac_len);
        memmove(skb_mac_header(skb), old_mac, skb->mac_len);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        err = 0;
 
 out:
 
                ip6_copy_metadata(frag, skb);
                skb_reserve(frag, LL_RESERVED_SPACE(rt->u.dst.dev));
                skb_put(frag, len + hlen + sizeof(struct frag_hdr));
-               frag->nh.raw = frag->data;
+               skb_reset_network_header(frag);
                fh = (struct frag_hdr*)(frag->data + hlen);
                frag->h.raw = frag->data + hlen + sizeof(struct frag_hdr);
 
                skb_put(skb,fragheaderlen + transhdrlen);
 
                /* initialize network header pointer */
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
 
                /* initialize protocol header pointer */
                skb->h.raw = skb->data + fragheaderlen;
 
        dst_release(skb2->dst);
        skb2->dst = NULL;
        skb_pull(skb2, offset);
-       skb2->nh.raw = skb2->data;
+       skb_reset_network_header(skb2);
        eiph = skb2->nh.iph;
 
        /* Try to guess incoming interface */
                dst_release(skb2->dst);
                skb2->dst = NULL;
                skb_pull(skb2, offset);
-               skb2->nh.raw = skb2->data;
+               skb_reset_network_header(skb2);
 
                /* Try to guess incoming interface */
                rt = rt6_lookup(&skb2->nh.ipv6h->saddr, NULL, 0, 0);
                }
                secpath_reset(skb);
                skb->mac.raw = skb->nh.raw;
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
                skb->protocol = htons(protocol);
                skb->pkt_type = PACKET_HOST;
                memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
 
        dst_release(skb2->dst);
        skb2->dst = NULL;
        skb_pull(skb2, skb->data - (u8*)iph6);
-       skb2->nh.raw = skb2->data;
+       skb_reset_network_header(skb2);
 
        /* Try to guess incoming interface */
        rt6i = rt6_lookup(&iph6->saddr, NULL, NULL, 0);
        if ((tunnel = ipip6_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
                secpath_reset(skb);
                skb->mac.raw = skb->nh.raw;
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
                IPCB(skb)->flags = 0;
                skb->protocol = htons(ETH_P_IPV6);
                skb->pkt_type = PACKET_HOST;
 
        skb->h.raw = skb->data + hdr_len;
        memmove(skb->data, iph, hdr_len);
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        top_iph = skb->nh.ipv6h;
        skb->nh.raw = &top_iph->nexthdr;
        skb->h.ipv6h = top_iph + 1;
 
        skb_push(skb, size);
        memmove(skb->data, skb->nh.raw, size);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        old_mac = skb_mac_header(skb);
        skb_set_mac_header(skb, -skb->mac_len);
 
        skb_push(skb, x->props.header_len);
        iph = skb->nh.ipv6h;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        top_iph = skb->nh.ipv6h;
        skb->nh.raw = &top_iph->nexthdr;
        skb->h.ipv6h = top_iph + 1;
        old_mac = skb_mac_header(skb);
        skb_set_mac_header(skb, -skb->mac_len);
        memmove(skb_mac_header(skb), old_mac, skb->mac_len);
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
        err = 0;
 
 out:
 
 
                spin_unlock_bh(&x->lock);
 
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
 
                if (!(skb->dst = dst_pop(dst))) {
                        err = -EHOSTUNREACH;
 
        /* Some common init stuff */
        skb->dev = self->netdev;
        skb_reset_mac_header(skb);
-       skb->h.raw = skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
+       skb->h.raw = skb->data;
        skb->protocol = htons(ETH_P_IRDA);
        skb->priority = TC_PRIO_BESTEFFORT;
 
 
                }
 
                skb->h.raw = skb->data;
-               skb->nh.raw = skb->data;
+               skb_reset_network_header(skb);
                skb->len = msg->length;
        }
 
 
        if (skb) {
                skb_reset_mac_header(skb);
                skb_reserve(skb, 50);
-               skb->nh.raw   = skb->h.raw = skb->data;
+               skb_reset_network_header(skb);
+               skb->h.raw = skb->data;
                skb->protocol = htons(ETH_P_802_2);
                skb->dev      = dev;
                if (sk != NULL)
 
        /* Spoof incoming device */
        skb->dev      = dev;
        skb_reset_mac_header(skb);
-       skb->nh.raw   = skb->data;
+       skb_reset_network_header(skb);
        skb->pkt_type = PACKET_HOST;
 
        netif_rx(skb);
 
         * notable one here. This should really be fixed at the driver level.
         */
        skb_reserve(skb, LL_RESERVED_SPACE(dev));
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        /* Try to align data part correctly */
        if (dev->hard_header) {
                skb->data -= dev->hard_header_len;
                skb->tail -= dev->hard_header_len;
                if (len < dev->hard_header_len)
-                       skb->nh.raw = skb->data;
+                       skb_reset_network_header(skb);
        }
 
        /* Returns -EFAULT on error */
                goto out_unlock;
 
        skb_reserve(skb, LL_RESERVED_SPACE(dev));
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        if (dev->hard_header) {
                int res;
 
 
        clone = skb_clone(buf, GFP_ATOMIC);
        if (clone) {
-               clone->nh.raw = clone->data;
+               skb_reset_network_header(clone);
                dev = ((struct eth_bearer *)(tb_ptr->usr_handle))->dev;
                clone->dev = dev;
                dev->hard_header(clone, dev, ETH_P_TIPC,
 
 {
        unsigned char *dptr;
 
-       skb->nh.raw = skb->data;
+       skb_reset_network_header(skb);
 
        switch (nb->dev->type) {
                case ARPHRD_X25: