[SK_BUFF]: Introduce skb_transport_header(skb)

For the places where we need a pointer to the transport header, it is
still legal to touch skb->h.raw directly if just adding to,
subtracting from or setting it to another layer header.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/appletalk/ltpc.c b/drivers/net/appletalk/ltpc.c
index dc3bce992dcf0280f1a5620dedf9e48ea3be0fff..43c17c85c97b83a1420f968eafe4e831c36b7da3 100644 (file)
--- a/drivers/net/appletalk/ltpc.c
+++ b/drivers/net/appletalk/ltpc.c
@@ -917,6 +917,7 @@ static int ltpc_xmit(struct sk_buff *skb, struct net_device *dev)
 
        int i;
        struct lt_sendlap cbuf;
+       unsigned char *hdr;
 
        cbuf.command = LT_SENDLAP;
        cbuf.dnode = skb->data[0];
@@ -932,11 +933,13 @@ static int ltpc_xmit(struct sk_buff *skb, struct net_device *dev)
                printk("\n");
        }
 
-       do_write(dev,&cbuf,sizeof(cbuf),skb->h.raw,skb->len);
+       hdr = skb_transport_header(skb);
+       do_write(dev, &cbuf, sizeof(cbuf), hdr, skb->len);
 
        if(debug & DEBUG_UPPER) {
                printk("sent %d ddp bytes\n",skb->len);
-               for(i=0;i<skb->len;i++) printk("%02x ",skb->h.raw[i]);
+               for (i = 0; i < skb->len; i++)
+                       printk("%02x ", hdr[i]);
                printk("\n");
        }
 

diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index a70fe9145a2e471bfc6021e00e6c578d7ef3ed02..610e4769efa463c3172f9f574af9d578391e4587 100644 (file)
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -1324,12 +1324,14 @@ static void write_ofld_wr(struct adapter *adap, struct sk_buff *skb,
 
        flits = skb_transport_offset(skb) / 8;
        sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
-       sgl_flits = make_sgl(skb, sgp, skb->h.raw, skb->tail - skb->h.raw,
+       sgl_flits = make_sgl(skb, sgp, skb_transport_header(skb),
+                            skb->tail - skb_transport_header(skb),
                             adap->pdev);
        if (need_skb_unmap()) {
                setup_deferred_unmapping(skb, adap->pdev, sgp, sgl_flits);
                skb->destructor = deferred_unmap_destructor;
-               ((struct unmap_info *)skb->cb)->len = skb->tail - skb->h.raw;
+               ((struct unmap_info *)skb->cb)->len = (skb->tail -
+                                                      skb_transport_header(skb));
        }
 
        write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits,
@@ -1351,7 +1353,7 @@ static inline unsigned int calc_tx_descs_ofld(const struct sk_buff *skb)
                return 1;       /* packet fits as immediate data */
 
        flits = skb_transport_offset(skb) / 8;  /* headers */
-       if (skb->tail != skb->h.raw)
+       if (skb->tail != skb_transport_header(skb))
                cnt++;
        return flits_to_desc(flits + sgl_len(cnt));
 }

diff --git a/drivers/s390/net/qeth_eddp.c b/drivers/s390/net/qeth_eddp.c
index b8e84674e1707393dd0ac9f60a7fad57c20820f3..5890bb5ad23ecb983a78fef325741650edf2adf0 100644 (file)
--- a/drivers/s390/net/qeth_eddp.c
+++ b/drivers/s390/net/qeth_eddp.c
@@ -476,13 +476,13 @@ qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
                eddp = qeth_eddp_create_eddp_data(qhdr,
                                                  skb_network_header(skb),
                                                  ip_hdrlen(skb),
-                                                 skb->h.raw,
+                                                 skb_transport_header(skb),
                                                  tcp_hdrlen(skb));
        else
                eddp = qeth_eddp_create_eddp_data(qhdr,
                                                  skb_network_header(skb),
                                                  sizeof(struct ipv6hdr),
-                                                 skb->h.raw,
+                                                 skb_transport_header(skb),
                                                  tcp_hdrlen(skb));
 
        if (eddp == NULL) {

diff --git a/include/linux/atalk.h b/include/linux/atalk.h
index d12984ddaa9fff9d65da2f0a0f617524a688a820..ced8a1ed080ca55d053a4ecd960cab4fe7fbfa9f 100644 (file)
--- a/include/linux/atalk.h
+++ b/include/linux/atalk.h
@@ -101,7 +101,7 @@ struct ddpehdr {
 
 static __inline__ struct ddpehdr *ddp_hdr(struct sk_buff *skb)
 {
-       return (struct ddpehdr *)skb->h.raw;
+       return (struct ddpehdr *)skb_transport_header(skb);
 }
 
 /* AppleTalk AARP headers */
@@ -129,7 +129,7 @@ struct elapaarp {
 
 static __inline__ struct elapaarp *aarp_hdr(struct sk_buff *skb)
 {
-       return (struct elapaarp *)skb->h.raw;
+       return (struct elapaarp *)skb_transport_header(skb);
 }
 
 /* Not specified - how long till we drop a resolved entry */

diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 1f4df61735f770029b4629d24ae292420831cabe..fdd4217f10471670e114003546bd8182d09ad70d 100644 (file)
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -260,19 +260,20 @@ enum {
 
 static inline struct dccp_hdr *dccp_hdr(const struct sk_buff *skb)
 {
-       return (struct dccp_hdr *)skb->h.raw;
+       return (struct dccp_hdr *)skb_transport_header(skb);
 }
 
 static inline struct dccp_hdr *dccp_zeroed_hdr(struct sk_buff *skb, int headlen)
 {
        skb_push(skb, headlen);
        skb_reset_transport_header(skb);
-       return memset(skb->h.raw, 0, headlen);
+       return memset(skb_transport_header(skb), 0, headlen);
 }
 
 static inline struct dccp_hdr_ext *dccp_hdrx(const struct sk_buff *skb)
 {
-       return (struct dccp_hdr_ext *)(skb->h.raw + sizeof(struct dccp_hdr));
+       return (struct dccp_hdr_ext *)(skb_transport_header(skb) +
+                                      sizeof(struct dccp_hdr));
 }
 
 static inline unsigned int __dccp_basic_hdr_len(const struct dccp_hdr *dh)
@@ -301,12 +302,14 @@ static inline __u64 dccp_hdr_seq(const struct sk_buff *skb)
 
 static inline struct dccp_hdr_request *dccp_hdr_request(struct sk_buff *skb)
 {
-       return (struct dccp_hdr_request *)(skb->h.raw + dccp_basic_hdr_len(skb));
+       return (struct dccp_hdr_request *)(skb_transport_header(skb) +
+                                          dccp_basic_hdr_len(skb));
 }
 
 static inline struct dccp_hdr_ack_bits *dccp_hdr_ack_bits(const struct sk_buff *skb)
 {
-       return (struct dccp_hdr_ack_bits *)(skb->h.raw + dccp_basic_hdr_len(skb));
+       return (struct dccp_hdr_ack_bits *)(skb_transport_header(skb) +
+                                           dccp_basic_hdr_len(skb));
 }
 
 static inline u64 dccp_hdr_ack_seq(const struct sk_buff *skb)
@@ -317,12 +320,14 @@ static inline u64 dccp_hdr_ack_seq(const struct sk_buff *skb)
 
 static inline struct dccp_hdr_response *dccp_hdr_response(struct sk_buff *skb)
 {
-       return (struct dccp_hdr_response *)(skb->h.raw + dccp_basic_hdr_len(skb));
+       return (struct dccp_hdr_response *)(skb_transport_header(skb) +
+                                           dccp_basic_hdr_len(skb));
 }
 
 static inline struct dccp_hdr_reset *dccp_hdr_reset(struct sk_buff *skb)
 {
-       return (struct dccp_hdr_reset *)(skb->h.raw + dccp_basic_hdr_len(skb));
+       return (struct dccp_hdr_reset *)(skb_transport_header(skb) +
+                                        dccp_basic_hdr_len(skb));
 }
 
 static inline unsigned int __dccp_hdr_len(const struct dccp_hdr *dh)

diff --git a/include/linux/icmp.h b/include/linux/icmp.h
index cd3017a157897da1cfcf2c7542deccec114194d0..474f2a51cf0af66474be229b626403975a36683c 100644 (file)
--- a/include/linux/icmp.h
+++ b/include/linux/icmp.h
@@ -87,7 +87,7 @@ struct icmphdr {
 
 static inline struct icmphdr *icmp_hdr(const struct sk_buff *skb)
 {
-       return (struct icmphdr *)skb->h.raw;
+       return (struct icmphdr *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h
index 0b5ba5eb7ed2175c83a3a86e855b3790de593f30..7c5e9817e998aaf0f8ec23de91ab0d39b1d237f5 100644 (file)
--- a/include/linux/icmpv6.h
+++ b/include/linux/icmpv6.h
@@ -80,7 +80,7 @@ struct icmp6hdr {
 
 static inline struct icmp6hdr *icmp6_hdr(const struct sk_buff *skb)
 {
-       return (struct icmp6hdr *)skb->h.raw;
+       return (struct icmp6hdr *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index ca285527b879af4faf9ea4bbac3233f5441fca95..f510e7e382a89f59c68ddc4e306bb32d8749d2ad 100644 (file)
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -85,19 +85,19 @@ struct igmpv3_query {
 
 static inline struct igmphdr *igmp_hdr(const struct sk_buff *skb)
 {
-       return (struct igmphdr *)skb->h.raw;
+       return (struct igmphdr *)skb_transport_header(skb);
 }
 
 static inline struct igmpv3_report *
                        igmpv3_report_hdr(const struct sk_buff *skb)
 {
-       return (struct igmpv3_report *)skb->h.raw;
+       return (struct igmpv3_report *)skb_transport_header(skb);
 }
 
 static inline struct igmpv3_query *
                        igmpv3_query_hdr(const struct sk_buff *skb)
 {
-       return (struct igmpv3_query *)skb->h.raw;
+       return (struct igmpv3_query *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/linux/ip.h b/include/linux/ip.h
index 19578440b5fcdaf5f9c05e4fff51530e3e7c2ee6..bd0a2a8631c60e6620578acc68c363540aea1755 100644 (file)
--- a/include/linux/ip.h
+++ b/include/linux/ip.h
@@ -114,7 +114,7 @@ static inline struct iphdr *ip_hdr(const struct sk_buff *skb)
 
 static inline struct iphdr *ipip_hdr(const struct sk_buff *skb)
 {
-       return (struct iphdr *)skb->h.raw;
+       return (struct iphdr *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index b768fcc0a4c414b72f81b36f1bde7308296ea23f..09ea01a8a99cf8ac4404bcb811862a66e7a97e83 100644 (file)
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -230,7 +230,7 @@ static inline struct ipv6hdr *ipv6_hdr(const struct sk_buff *skb)
 
 static inline struct ipv6hdr *ipipv6_hdr(const struct sk_buff *skb)
 {
-       return (struct ipv6hdr *)skb->h.raw;
+       return (struct ipv6hdr *)skb_transport_header(skb);
 }
 
 /* 

diff --git a/include/linux/sctp.h b/include/linux/sctp.h
index d76767dfe59e5f563eaefef6c49ff057aba270d8..d70df61a029f78a8c2234bde6f6625b4c0f71cf2 100644 (file)
--- a/include/linux/sctp.h
+++ b/include/linux/sctp.h
@@ -68,7 +68,7 @@ typedef struct sctphdr {
 
 static inline struct sctphdr *sctp_hdr(const struct sk_buff *skb)
 {
-       return (struct sctphdr *)skb->h.raw;
+       return (struct sctphdr *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index d3f186230ee2784cbbd80c652f367146e869ae02..39a6da243b24ab0d8fca08ca4d9999aa03f68f13 100644 (file)
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -951,6 +951,11 @@ static inline void skb_reserve(struct sk_buff *skb, int len)
        skb->tail += len;
 }
 
+static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
+{
+       return skb->h.raw;
+}
+
 static inline void skb_reset_transport_header(struct sk_buff *skb)
 {
        skb->h.raw = skb->data;

diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 911d937fb4c1c73dd0f138459b2295635e3ca91c..c6b9f92e8289949bde61f0ea384f48349d5a083f 100644 (file)
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -180,7 +180,7 @@ struct tcp_md5sig {
 
 static inline struct tcphdr *tcp_hdr(const struct sk_buff *skb)
 {
-       return (struct tcphdr *)skb->h.raw;
+       return (struct tcphdr *)skb_transport_header(skb);
 }
 
 static inline unsigned int tcp_hdrlen(const struct sk_buff *skb)

diff --git a/include/linux/udp.h b/include/linux/udp.h
index 1f58503af9a6c430b32583d4b06a846824bcc256..6de445c31a6492ae2aee3d1a906a7e993c3b64cb 100644 (file)
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -31,7 +31,7 @@ struct udphdr {
 
 static inline struct udphdr *udp_hdr(const struct sk_buff *skb)
 {
-       return (struct udphdr *)skb->h.raw;
+       return (struct udphdr *)skb_transport_header(skb);
 }
 #endif
 

diff --git a/include/net/ipx.h b/include/net/ipx.h
index c6b2ee610866bff73e779cc0e772e83dbd1b741c..4cc0b4eca948b471159b29f1f6f7459d8989bd17 100644 (file)
--- a/include/net/ipx.h
+++ b/include/net/ipx.h
@@ -43,7 +43,7 @@ struct ipxhdr {
 
 static __inline__ struct ipxhdr *ipx_hdr(struct sk_buff *skb)
 {
-       return (struct ipxhdr *)skb->h.raw;
+       return (struct ipxhdr *)skb_transport_header(skb);
 }
 
 struct ipx_interface {

diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index 880eb7b541643880a0870017948162d4212a9fa1..dcb3a91f136434975386011eb1bbf86b10e43c47 100644 (file)
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -328,7 +328,7 @@ static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
                case TCF_LAYER_NETWORK:
                        return skb_network_header(skb);
                case TCF_LAYER_TRANSPORT:
-                       return skb->h.raw;
+                       return skb_transport_header(skb);
        }
 
        return NULL;

diff --git a/include/net/udp.h b/include/net/udp.h
index 4a9699f79281153d62ebf38b08f2713a1067cd64..4906ed7113e7e887df984560b0a0d23d1789167d 100644 (file)
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -89,8 +89,8 @@ static inline int udp_lib_checksum_complete(struct sk_buff *skb)
  */
 static inline __wsum udp_csum_outgoing(struct sock *sk, struct sk_buff *skb)
 {
-       __wsum csum = csum_partial(skb->h.raw, sizeof(struct udphdr), 0);
-
+       __wsum csum = csum_partial(skb_transport_header(skb),
+                                  sizeof(struct udphdr), 0);
        skb_queue_walk(&sk->sk_write_queue, skb) {
                csum = csum_add(csum, skb->csum);
        }

diff --git a/net/802/psnap.c b/net/802/psnap.c
index 6e7c2120b83ff6a678ca0e3e33f377b713a711cf..7cba1f426081b61f45886c28f53a2cea5b93f602 100644 (file)
--- a/net/802/psnap.c
+++ b/net/802/psnap.c
@@ -56,7 +56,7 @@ static int snap_rcv(struct sk_buff *skb, struct net_device *dev,
        };
 
        rcu_read_lock();
-       proto = find_snap_client(skb->h.raw);
+       proto = find_snap_client(skb_transport_header(skb));
        if (proto) {
                /* Pass the frame on. */
                skb->h.raw  += 5;

diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 75d4d695edecb7fbf1a1b29fa02d06b0a555c140..5f28887822e9d1b49265c0c19c3dbccb1e163ded 100644 (file)
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1585,9 +1585,10 @@ static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
 
        skb_set_transport_header(skb, lv);
 
-       SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, skb->h.raw);
+       SOCK_DEBUG(sk, "base=%p pos=%p\n",
+                  skb->data, skb_transport_header(skb));
 
-       *skb->h.raw = AX25_UI;
+       *skb_transport_header(skb) = AX25_UI;
 
        /* Datagram frames go straight out of the door as UI */
        ax25_queue_xmit(skb, ax25->ax25_dev->dev);

diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index c11ceb6b3f79c1d6082822ea3bba729d9183bc15..c177e75d64a6b601d7bbd75bcb6415f83a180ed1 100644 (file)
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -1076,7 +1076,7 @@ static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags)
 
        skb_push(skb, HCI_ACL_HDR_SIZE);
        skb_reset_transport_header(skb);
-       hdr = (struct hci_acl_hdr *)skb->h.raw;
+       hdr = (struct hci_acl_hdr *)skb_transport_header(skb);
        hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
        hdr->dlen   = cpu_to_le16(len);
 }
@@ -1145,7 +1145,7 @@ int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb)
 
        skb_push(skb, HCI_SCO_HDR_SIZE);
        skb_reset_transport_header(skb);
-       memcpy(skb->h.raw, &hdr, HCI_SCO_HDR_SIZE);
+       memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE);
 
        skb->dev = (void *) hdev;
        bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;

diff --git a/net/core/dev.c b/net/core/dev.c
index f7f7e5687e462a459a8395d2ed5f273aa0eaee74..30fcc7f9d4edde76a685fc9d0f4ef5e1628a9ca0 100644 (file)
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1175,12 +1175,12 @@ int skb_checksum_help(struct sk_buff *skb)
        BUG_ON(offset > (int)skb->len);
        csum = skb_checksum(skb, offset, skb->len-offset, 0);
 
-       offset = skb->tail - skb->h.raw;
+       offset = skb->tail - skb_transport_header(skb);
        BUG_ON(offset <= 0);
        BUG_ON(skb->csum_offset + 2 > offset);
 
-       *(__sum16*)(skb->h.raw + skb->csum_offset) = csum_fold(csum);
-
+       *(__sum16 *)(skb_transport_header(skb) +
+                    skb->csum_offset) = csum_fold(csum);
 out_set_summed:
        skb->ip_summed = CHECKSUM_NONE;
 out:

diff --git a/net/econet/af_econet.c b/net/econet/af_econet.c
index dcc2e4b6b2fed3f463413d4bb9d796c39b379999..78993dadb53a9f5802302839bb8c2d1d84deb20b 100644 (file)
--- a/net/econet/af_econet.c
+++ b/net/econet/af_econet.c
@@ -943,7 +943,7 @@ static void aun_data_available(struct sock *sk, int slen)
                printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
        }
 
-       data = skb->h.raw + sizeof(struct udphdr);
+       data = skb_transport_header(skb) + sizeof(struct udphdr);
        ah = (struct aunhdr *)data;
        len = skb->len - sizeof(struct udphdr);
        ip = ip_hdr(skb);

diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index 292516bb1eca89cb8721abc1d8c5cd830f029ed3..8f0df7b4dfe7539752532d1559cc38b5a4388692 100644 (file)
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -348,7 +348,7 @@ static int igmpv3_sendpack(struct sk_buff *skb)
        struct iphdr *pip = ip_hdr(skb);
        struct igmphdr *pig = igmp_hdr(skb);
        const int iplen = skb->tail - skb->nh.raw;
-       const int igmplen = skb->tail - skb->h.raw;
+       const int igmplen = skb->tail - skb_transport_header(skb);
 
        pip->tot_len = htons(iplen);
        ip_send_check(pip);

diff --git a/net/ipv4/ip_gre.c b/net/ipv4/ip_gre.c
index 39216e6a59edf39a0d28edb319a973cdd078fac8..e6a9e452fd613094ccb8f0c1bdc35fad290317f7 100644 (file)
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@ -619,7 +619,7 @@ static int ipgre_rcv(struct sk_buff *skb)
                skb_reset_mac_header(skb);
                __pskb_pull(skb, offset);
                skb_reset_network_header(skb);
-               skb_postpull_rcsum(skb, skb->h.raw, offset);
+               skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
                skb->pkt_type = PACKET_HOST;
 #ifdef CONFIG_NET_IPGRE_BROADCAST
                if (MULTICAST(iph->daddr)) {

diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index 602268661eb31835ff1738f60e22ef930524b852..11029b9d4cf7dea9427691b9c1d2cf4dcfe7c565 100644 (file)
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -1128,7 +1128,7 @@ ssize_t   ip_append_page(struct sock *sk, struct page *page,
                        if (fraggap) {
                                skb->csum = skb_copy_and_csum_bits(skb_prev,
                                                                   maxfraglen,
-                                                                  skb->h.raw,
+                                                   skb_transport_header(skb),
                                                                   fraggap, 0);
                                skb_prev->csum = csum_sub(skb_prev->csum,
                                                          skb->csum);
@@ -1374,7 +1374,9 @@ void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *ar
                       &ipc, rt, MSG_DONTWAIT);
        if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
                if (arg->csumoffset >= 0)
-                       *((__sum16 *)skb->h.raw + arg->csumoffset) = csum_fold(csum_add(skb->csum, arg->csum));
+                       *((__sum16 *)skb_transport_header(skb) +
+                         arg->csumoffset) = csum_fold(csum_add(skb->csum,
+                                                               arg->csum));
                skb->ip_summed = CHECKSUM_NONE;
                ip_push_pending_frames(sk);
        }

diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 6b91c9f5d57adb5f9707887bbacba38dba03bd21..4e19ee0e0102b261a00784cb2f5f4953db9cf9e9 100644 (file)
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -432,7 +432,7 @@ ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
                goto drop;
 
        /* Basic sanity checks can be done without the lock.  */
-       rarp = (struct arphdr *)skb->h.raw;
+       rarp = (struct arphdr *)skb_transport_header(skb);
 
        /* If this test doesn't pass, it's not IP, or we should
         * ignore it anyway.
@@ -455,7 +455,7 @@ ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt
                goto drop;
 
        /* OK, it is all there and looks valid, process... */
-       rarp = (struct arphdr *)skb->h.raw;
+       rarp = (struct arphdr *)skb_transport_header(skb);
        rarp_ptr = (unsigned char *) (rarp + 1);
 
        /* One reply at a time, please. */

diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index 05bc27002def409799eb3b1c49b9f395758efcc9..8f45c95db451a2f4083785b6454d89fb72018376 100644 (file)
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -1437,7 +1437,8 @@ int pim_rcv_v1(struct sk_buff * skb)
            pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
                goto drop;
 
-       encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
+       encap = (struct iphdr *)(skb_transport_header(skb) +
+                                sizeof(struct igmphdr));
        /*
           Check that:
           a. packet is really destinted to a multicast group
@@ -1490,7 +1491,7 @@ static int pim_rcv(struct sk_buff * skb)
        if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
                goto drop;
 
-       pim = (struct pimreghdr*)skb->h.raw;
+       pim = (struct pimreghdr *)skb_transport_header(skb);
        if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
            (pim->flags&PIM_NULL_REGISTER) ||
            (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
@@ -1498,7 +1499,8 @@ static int pim_rcv(struct sk_buff * skb)
                goto drop;
 
        /* check if the inner packet is destined to mcast group */
-       encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
+       encap = (struct iphdr *)(skb_transport_header(skb) +
+                                sizeof(struct pimreghdr));
        if (!MULTICAST(encap->daddr) ||
            encap->tot_len == 0 ||
            ntohs(encap->tot_len) + sizeof(*pim) > skb->len)

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index f832f3c33ab1d89a125406d45dac1039f20f9d62..2b214cc3724cc0a958189140d00f2a479dba371e 100644 (file)
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2219,8 +2219,9 @@ struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features)
                th->check = ~csum_fold((__force __wsum)((__force u32)th->check +
                                       (__force u32)delta));
                if (skb->ip_summed != CHECKSUM_PARTIAL)
-                       th->check = csum_fold(csum_partial(skb->h.raw, thlen,
-                                                          skb->csum));
+                       th->check =
+                            csum_fold(csum_partial(skb_transport_header(skb),
+                                                   thlen, skb->csum));
 
                seq += len;
                skb = skb->next;
@@ -2230,12 +2231,13 @@ struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features)
                th->cwr = 0;
        } while (skb->next);
 
-       delta = htonl(oldlen + (skb->tail - skb->h.raw) + skb->data_len);
+       delta = htonl(oldlen + (skb->tail - skb_transport_header(skb)) +
+                     skb->data_len);
        th->check = ~csum_fold((__force __wsum)((__force u32)th->check +
                                (__force u32)delta));
        if (skb->ip_summed != CHECKSUM_PARTIAL)
-               th->check = csum_fold(csum_partial(skb->h.raw, thlen,
-                                                  skb->csum));
+               th->check = csum_fold(csum_partial(skb_transport_header(skb),
+                                                  thlen, skb->csum));
 
 out:
        return segs;

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index c1ce362373807127aeb4447856a1052fbfbb9202..9c3b4c7a50ad1a1dd82e914a4c219d837a1fa816 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -140,7 +140,7 @@ static void tcp_measure_rcv_mss(struct sock *sk,
                 *
                 * "len" is invariant segment length, including TCP header.
                 */
-               len += skb->data - skb->h.raw;
+               len += skb->data - skb_transport_header(skb);
                if (len >= TCP_MIN_RCVMSS + sizeof(struct tcphdr) ||
                    /* If PSH is not set, packet should be
                     * full sized, provided peer TCP is not badly broken.
@@ -940,7 +940,8 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
 {
        const struct inet_connection_sock *icsk = inet_csk(sk);
        struct tcp_sock *tp = tcp_sk(sk);
-       unsigned char *ptr = ack_skb->h.raw + TCP_SKB_CB(ack_skb)->sacked;
+       unsigned char *ptr = (skb_transport_header(ack_skb) +
+                             TCP_SKB_CB(ack_skb)->sacked);
        struct tcp_sack_block_wire *sp = (struct tcp_sack_block_wire *)(ptr+2);
        struct sk_buff *cached_skb;
        int num_sacks = (ptr[1] - TCPOLEN_SACK_BASE)>>3;
@@ -3634,10 +3635,10 @@ tcp_collapse(struct sock *sk, struct sk_buff_head *list,
                        return;
 
                skb_set_mac_header(nskb, skb_mac_header(skb) - skb->head);
-               skb_set_network_header(nskb,
-                                      skb_network_header(skb) - skb->head);
-               skb_set_transport_header(nskb, skb->h.raw - skb->head);
-
+               skb_set_network_header(nskb, (skb_network_header(skb) -
+                                             skb->head));
+               skb_set_transport_header(nskb, (skb_transport_header(skb) -
+                                               skb->head));
                skb_reserve(nskb, header);
                memcpy(nskb->head, skb->head, header);
                memcpy(nskb->cb, skb->cb, sizeof(skb->cb));

diff --git a/net/ipv4/xfrm4_mode_beet.c b/net/ipv4/xfrm4_mode_beet.c
index 32fcfc0b5c8c10d6a5a8e9a954b33592523c8601..591f0f1ef87fab136f72f4f26d480cd77cca08b0 100644 (file)
--- a/net/ipv4/xfrm4_mode_beet.c
+++ b/net/ipv4/xfrm4_mode_beet.c
@@ -51,7 +51,7 @@ static int xfrm4_beet_output(struct xfrm_state *x, struct sk_buff *skb)
 
                BUG_ON(optlen < 0);
 
-               ph = (struct ip_beet_phdr *)skb->h.raw;
+               ph = (struct ip_beet_phdr *)skb_transport_header(skb);
                ph->padlen = 4 - (optlen & 4);
                ph->hdrlen = optlen / 8;
                ph->nexthdr = top_iph->protocol;

diff --git a/net/ipv4/xfrm4_mode_transport.c b/net/ipv4/xfrm4_mode_transport.c
index 2c46cbb3bbb538dfb47dd80208eb18af4d071cae..dc8834ea3754746892ab9a9cc7b1cff33096c070 100644 (file)
--- a/net/ipv4/xfrm4_mode_transport.c
+++ b/net/ipv4/xfrm4_mode_transport.c
@@ -45,10 +45,11 @@ static int xfrm4_transport_output(struct xfrm_state *x, struct sk_buff *skb)
  */
 static int xfrm4_transport_input(struct xfrm_state *x, struct sk_buff *skb)
 {
-       int ihl = skb->data - skb->h.raw;
+       int ihl = skb->data - skb_transport_header(skb);
 
        if (skb->h.raw != skb->nh.raw) {
-               memmove(skb->h.raw, skb_network_header(skb), ihl);
+               memmove(skb_transport_header(skb),
+                       skb_network_header(skb), ihl);
                skb->nh.raw = skb->h.raw;
        }
        ip_hdr(skb)->tot_len = htons(skb->len + ihl);

diff --git a/net/ipv6/ah6.c b/net/ipv6/ah6.c
index e5ee981d3e10a8e80fac479a4975afbab57f4946..d2af4fe3725b7b9fdb8030a4a08fe3a2ce9c78b9 100644 (file)
--- a/net/ipv6/ah6.c
+++ b/net/ipv6/ah6.c
@@ -268,7 +268,7 @@ static int ah6_output(struct xfrm_state *x, struct sk_buff *skb)
                        goto error_free_iph;
        }
 
-       ah = (struct ip_auth_hdr *)skb->h.raw;
+       ah = (struct ip_auth_hdr *)skb_transport_header(skb);
        ah->nexthdr = nexthdr;
 
        top_iph->priority    = 0;

diff --git a/net/ipv6/esp6.c b/net/ipv6/esp6.c
index ad522b7b5771ab435d1330726c082b7193228879..436eb9e6a6cf66fcd86284a615c9417facdd7d7f 100644 (file)
--- a/net/ipv6/esp6.c
+++ b/net/ipv6/esp6.c
@@ -87,7 +87,7 @@ static int esp6_output(struct xfrm_state *x, struct sk_buff *skb)
        pskb_put(skb, trailer, clen - skb->len);
 
        top_iph = (struct ipv6hdr *)__skb_push(skb, hdr_len);
-       esph = (struct ipv6_esp_hdr *)skb->h.raw;
+       esph = (struct ipv6_esp_hdr *)skb_transport_header(skb);
        top_iph->payload_len = htons(skb->len + alen - sizeof(*top_iph));
        *(u8 *)(trailer->tail - 1) = *skb_network_header(skb);
        *skb_network_header(skb) = IPPROTO_ESP;

diff --git a/net/ipv6/exthdrs.c b/net/ipv6/exthdrs.c
index 1bda0299890ee457555a6b82d5483d6b696be875..f25ee773f52eb14b0d9cb6b1b3d0bf34660d1a5c 100644 (file)
--- a/net/ipv6/exthdrs.c
+++ b/net/ipv6/exthdrs.c
@@ -144,7 +144,7 @@ static int ip6_parse_tlv(struct tlvtype_proc *procs, struct sk_buff **skbp)
        struct tlvtype_proc *curr;
        const unsigned char *nh = skb_network_header(skb);
        int off = skb->h.raw - skb->nh.raw;
-       int len = ((skb->h.raw[1]+1)<<3);
+       int len = (skb_transport_header(skb)[1] + 1) << 3;
 
        if (skb_transport_offset(skb) + len > skb_headlen(skb))
                goto bad;
@@ -290,15 +290,14 @@ static int ipv6_destopt_rcv(struct sk_buff **skbp)
 
        if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
            !pskb_may_pull(skb, (skb_transport_offset(skb) +
-                                ((skb->h.raw[1] + 1) << 3)))) {
+                                ((skb_transport_header(skb)[1] + 1) << 3)))) {
                IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
                                 IPSTATS_MIB_INHDRERRORS);
                kfree_skb(skb);
                return -1;
        }
 
-       opt->lastopt = skb->h.raw - skb->nh.raw;
-       opt->dst1 = skb->h.raw - skb->nh.raw;
+       opt->lastopt = opt->dst1 = skb->h.raw - skb->nh.raw;
 #ifdef CONFIG_IPV6_MIP6
        dstbuf = opt->dst1;
 #endif
@@ -307,7 +306,7 @@ static int ipv6_destopt_rcv(struct sk_buff **skbp)
        if (ip6_parse_tlv(tlvprocdestopt_lst, skbp)) {
                dst_release(dst);
                skb = *skbp;
-               skb->h.raw += ((skb->h.raw[1]+1)<<3);
+               skb->h.raw += (skb_transport_header(skb)[1] + 1) << 3;
                opt = IP6CB(skb);
 #ifdef CONFIG_IPV6_MIP6
                opt->nhoff = dstbuf;
@@ -390,14 +389,14 @@ static int ipv6_rthdr_rcv(struct sk_buff **skbp)
 
        if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
            !pskb_may_pull(skb, (skb_transport_offset(skb) +
-                                ((skb->h.raw[1] + 1) << 3)))) {
+                                ((skb_transport_header(skb)[1] + 1) << 3)))) {
                IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
                                 IPSTATS_MIB_INHDRERRORS);
                kfree_skb(skb);
                return -1;
        }
 
-       hdr = (struct ipv6_rt_hdr *) skb->h.raw;
+       hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb);
 
        switch (hdr->type) {
 #ifdef CONFIG_IPV6_MIP6
@@ -444,8 +443,7 @@ looped_back:
                        break;
                }
 
-               opt->lastopt = skb->h.raw - skb->nh.raw;
-               opt->srcrt = skb->h.raw - skb->nh.raw;
+               opt->lastopt = opt->srcrt = skb->h.raw - skb->nh.raw;
                skb->h.raw += (hdr->hdrlen + 1) << 3;
                opt->dst0 = opt->dst1;
                opt->dst1 = 0;
@@ -745,7 +743,8 @@ int ipv6_parse_hopopts(struct sk_buff **skbp)
         * hop-by-hop options.
         */
        if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + 8) ||
-           !pskb_may_pull(skb, sizeof(struct ipv6hdr) + ((skb->h.raw[1] + 1) << 3))) {
+           !pskb_may_pull(skb, (sizeof(struct ipv6hdr) +
+                                ((skb_transport_header(skb)[1] + 1) << 3)))) {
                kfree_skb(skb);
                return -1;
        }
@@ -753,7 +752,7 @@ int ipv6_parse_hopopts(struct sk_buff **skbp)
        opt->hop = sizeof(struct ipv6hdr);
        if (ip6_parse_tlv(tlvprochopopt_lst, skbp)) {
                skb = *skbp;
-               skb->h.raw += (skb->h.raw[1]+1)<<3;
+               skb->h.raw += (skb_transport_header(skb)[1] + 1) << 3;
                opt = IP6CB(skb);
                opt->nhoff = sizeof(struct ipv6hdr);
                return 1;

diff --git a/net/ipv6/ipcomp6.c b/net/ipv6/ipcomp6.c
index 4a6501695e98d5d5de163c7d0c1b88ae50303b57..5555c98dea03b3484fe228d817cf4ea735bf2052 100644 (file)
--- a/net/ipv6/ipcomp6.c
+++ b/net/ipv6/ipcomp6.c
@@ -143,7 +143,7 @@ static int ipcomp6_output(struct xfrm_state *x, struct sk_buff *skb)
        /* compression */
        plen = skb->len - hdr_len;
        dlen = IPCOMP_SCRATCH_SIZE;
-       start = skb->h.raw;
+       start = skb_transport_header(skb);
 
        cpu = get_cpu();
        scratch = *per_cpu_ptr(ipcomp6_scratches, cpu);

diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index 1f2a3be9308a3e229512ab6b1a4cbba57800a9cc..c6436f5e3e9ff7e37bc1f18ed3909e60a11d1ca0 100644 (file)
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -1212,7 +1212,7 @@ int igmp6_event_query(struct sk_buff *skb)
                        in6_dev_put(idev);
                        return -EINVAL;
                }
-               mlh2 = (struct mld2_query *) skb->h.raw;
+               mlh2 = (struct mld2_query *)skb_transport_header(skb);
                max_delay = (MLDV2_MRC(ntohs(mlh2->mrc))*HZ)/1000;
                if (!max_delay)
                        max_delay = 1;
@@ -1235,7 +1235,7 @@ int igmp6_event_query(struct sk_buff *skb)
                                in6_dev_put(idev);
                                return -EINVAL;
                        }
-                       mlh2 = (struct mld2_query *) skb->h.raw;
+                       mlh2 = (struct mld2_query *)skb_transport_header(skb);
                        mark = 1;
                }
        } else {
@@ -1460,18 +1460,20 @@ static inline int mld_dev_queue_xmit(struct sk_buff *skb)
 static void mld_sendpack(struct sk_buff *skb)
 {
        struct ipv6hdr *pip6 = ipv6_hdr(skb);
-       struct mld2_report *pmr = (struct mld2_report *)skb->h.raw;
+       struct mld2_report *pmr =
+                             (struct mld2_report *)skb_transport_header(skb);
        int payload_len, mldlen;
        struct inet6_dev *idev = in6_dev_get(skb->dev);
        int err;
 
        IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
        payload_len = skb->tail - skb_network_header(skb) - sizeof(*pip6);
-       mldlen = skb->tail - skb->h.raw;
+       mldlen = skb->tail - skb_transport_header(skb);
        pip6->payload_len = htons(payload_len);
 
        pmr->csum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen,
-               IPPROTO_ICMPV6, csum_partial(skb->h.raw, mldlen, 0));
+               IPPROTO_ICMPV6, csum_partial(skb_transport_header(skb),
+                                            mldlen, 0));
        err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, skb->dev,
                mld_dev_queue_xmit);
        if (!err) {
@@ -1505,7 +1507,7 @@ static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc,
        pgr->grec_auxwords = 0;
        pgr->grec_nsrcs = 0;
        pgr->grec_mca = pmc->mca_addr;  /* structure copy */
-       pmr = (struct mld2_report *)skb->h.raw;
+       pmr = (struct mld2_report *)skb_transport_header(skb);
        pmr->ngrec = htons(ntohs(pmr->ngrec)+1);
        *ppgr = pgr;
        return skb;
@@ -1538,7 +1540,7 @@ static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc,
        if (!*psf_list)
                goto empty_source;
 
-       pmr = skb ? (struct mld2_report *)skb->h.raw : NULL;
+       pmr = skb ? (struct mld2_report *)skb_transport_header(skb) : NULL;
 
        /* EX and TO_EX get a fresh packet, if needed */
        if (truncate) {

diff --git a/net/ipv6/mip6.c b/net/ipv6/mip6.c
index 85202891644e55a977997102c31be113aaacd4aa..f0288e92fb52ef0ac496648d73f74214c57590ca 100644 (file)
--- a/net/ipv6/mip6.c
+++ b/net/ipv6/mip6.c
@@ -92,10 +92,10 @@ int mip6_mh_filter(struct sock *sk, struct sk_buff *skb)
 
        if (!pskb_may_pull(skb, (skb_transport_offset(skb)) + 8) ||
            !pskb_may_pull(skb, (skb_transport_offset(skb) +
-                                ((skb->h.raw[1] + 1) << 3))))
+                                ((skb_transport_header(skb)[1] + 1) << 3))))
                return -1;
 
-       mh = (struct ip6_mh *)skb->h.raw;
+       mh = (struct ip6_mh *)skb_transport_header(skb);
 
        if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) {
                LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH message too short: %d vs >=%d\n",
@@ -158,7 +158,7 @@ static int mip6_destopt_output(struct xfrm_state *x, struct sk_buff *skb)
        nexthdr = *skb_network_header(skb);
        *skb_network_header(skb) = IPPROTO_DSTOPTS;
 
-       dstopt = (struct ipv6_destopt_hdr *)skb->h.raw;
+       dstopt = (struct ipv6_destopt_hdr *)skb_transport_header(skb);
        dstopt->nexthdr = nexthdr;
 
        hao = mip6_padn((char *)(dstopt + 1),
@@ -370,7 +370,7 @@ static int mip6_rthdr_output(struct xfrm_state *x, struct sk_buff *skb)
        nexthdr = *skb_network_header(skb);
        *skb_network_header(skb) = IPPROTO_ROUTING;
 
-       rt2 = (struct rt2_hdr *)skb->h.raw;
+       rt2 = (struct rt2_hdr *)skb_transport_header(skb);
        rt2->rt_hdr.nexthdr = nexthdr;
        rt2->rt_hdr.hdrlen = (x->props.header_len >> 3) - 1;
        rt2->rt_hdr.type = IPV6_SRCRT_TYPE_2;

diff --git a/net/ipv6/ndisc.c b/net/ipv6/ndisc.c
index 8b946f56287af13e5a1a5e5c65b78d42cce7cbc1..f9a85ab594db07a4a58186254077e129d7d9df6f 100644 (file)
--- a/net/ipv6/ndisc.c
+++ b/net/ipv6/ndisc.c
@@ -760,7 +760,7 @@ static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
 
 static void ndisc_recv_ns(struct sk_buff *skb)
 {
-       struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
+       struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
        struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
        struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
        u8 *lladdr = NULL;
@@ -938,7 +938,7 @@ out:
 
 static void ndisc_recv_na(struct sk_buff *skb)
 {
-       struct nd_msg *msg = (struct nd_msg *)skb->h.raw;
+       struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
        struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
        struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
        u8 *lladdr = NULL;
@@ -1040,7 +1040,7 @@ out:
 
 static void ndisc_recv_rs(struct sk_buff *skb)
 {
-       struct rs_msg *rs_msg = (struct rs_msg *) skb->h.raw;
+       struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
        unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
        struct neighbour *neigh;
        struct inet6_dev *idev;
@@ -1097,7 +1097,7 @@ out:
 
 static void ndisc_router_discovery(struct sk_buff *skb)
 {
-       struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;
+       struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
        struct neighbour *neigh = NULL;
        struct inet6_dev *in6_dev;
        struct rt6_info *rt = NULL;
@@ -1108,7 +1108,8 @@ static void ndisc_router_discovery(struct sk_buff *skb)
 
        __u8 * opt = (__u8 *)(ra_msg + 1);
 
-       optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);
+       optlen = (skb->tail - skb_transport_header(skb)) -
+                 sizeof(struct ra_msg);
 
        if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
                ND_PRINTK2(KERN_WARNING
@@ -1357,7 +1358,7 @@ static void ndisc_redirect_rcv(struct sk_buff *skb)
                return;
        }
 
-       optlen = skb->tail - skb->h.raw;
+       optlen = skb->tail - skb_transport_header(skb);
        optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
 
        if (optlen < 0) {
@@ -1584,9 +1585,9 @@ int ndisc_rcv(struct sk_buff *skb)
        if (!pskb_may_pull(skb, skb->len))
                return 0;
 
-       msg = (struct nd_msg *) skb->h.raw;
+       msg = (struct nd_msg *)skb_transport_header(skb);
 
-       __skb_push(skb, skb->data-skb->h.raw);
+       __skb_push(skb, skb->data - skb_transport_header(skb));
 
        if (ipv6_hdr(skb)->hop_limit != 255) {
                ND_PRINTK2(KERN_WARNING

diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index bb049f1c2679fca77d9d36b5674b65d4c31c6745..116257d59a36ef379426c87d153c143faa7ca4c1 100644 (file)
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -1077,7 +1077,7 @@ static int rawv6_ioctl(struct sock *sk, int cmd, unsigned long arg)
                        spin_lock_bh(&sk->sk_receive_queue.lock);
                        skb = skb_peek(&sk->sk_receive_queue);
                        if (skb != NULL)
-                               amount = skb->tail - skb->h.raw;
+                               amount = skb->tail - skb_transport_header(skb);
                        spin_unlock_bh(&sk->sk_receive_queue.lock);
                        return put_user(amount, (int __user *)arg);
                }

diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index ef29a7bb97cef3b4d422fd0ebaefccd81a6ca970..31d4271ea54051ff99da27517fa00e2ed78099a6 100644 (file)
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -726,7 +726,7 @@ static int ipv6_frag_rcv(struct sk_buff **skbp)
        }
 
        hdr = ipv6_hdr(skb);
-       fhdr = (struct frag_hdr *)skb->h.raw;
+       fhdr = (struct frag_hdr *)skb_transport_header(skb);
 
        if (!(fhdr->frag_off & htons(0xFFF9))) {
                /* It is not a fragmented frame */

diff --git a/net/ipv6/xfrm6_mode_transport.c b/net/ipv6/xfrm6_mode_transport.c
index 0134d74ef087fdfde24e5c58c5bf0d3d9bc4a3dd..d526f4e9c65e5a1324158d2e39cab3d7bd2de95d 100644 (file)
--- a/net/ipv6/xfrm6_mode_transport.c
+++ b/net/ipv6/xfrm6_mode_transport.c
@@ -51,10 +51,11 @@ static int xfrm6_transport_output(struct xfrm_state *x, struct sk_buff *skb)
  */
 static int xfrm6_transport_input(struct xfrm_state *x, struct sk_buff *skb)
 {
-       int ihl = skb->data - skb->h.raw;
+       int ihl = skb->data - skb_transport_header(skb);
 
        if (skb->h.raw != skb->nh.raw) {
-               memmove(skb->h.raw, skb_network_header(skb), ihl);
+               memmove(skb_transport_header(skb),
+                       skb_network_header(skb), ihl);
                skb->nh.raw = skb->h.raw;
        }
        ipv6_hdr(skb)->payload_len = htons(skb->len + ihl -

diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index ee15bdae14196d092b85ce9aa5123e5d128d0a25..5c4695840c58bde90bd0ba1ffc1abcc251dd25ad 100644 (file)
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -62,7 +62,7 @@ int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq)
        case IPPROTO_COMP:
                if (!pskb_may_pull(skb, sizeof(struct ip_comp_hdr)))
                        return -EINVAL;
-               *spi = htonl(ntohs(*(__be16*)(skb->h.raw + 2)));
+               *spi = htonl(ntohs(*(__be16*)(skb_transport_header(skb) + 2)));
                *seq = 0;
                return 0;
        default:
@@ -72,8 +72,8 @@ int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq)
        if (!pskb_may_pull(skb, 16))
                return -EINVAL;
 
-       *spi = *(__be32*)(skb->h.raw + offset);
-       *seq = *(__be32*)(skb->h.raw + offset_seq);
+       *spi = *(__be32*)(skb_transport_header(skb) + offset);
+       *seq = *(__be32*)(skb_transport_header(skb) + offset_seq);
        return 0;
 }
 EXPORT_SYMBOL(xfrm_parse_spi);