net: qualcomm: rmnet: IPv4 header has zero checksum

In rmnet_map_ipv4_dl_csum_trailer(), an illegal checksum subtraction
is done, subtracting hdr_csum (in host byte order) from csum_value (in
network byte order).  Despite being illegal, it generally works,
because it turns out the value subtracted is (or should be) always 0,
which has the same representation in either byte order.

Doing illegal operations is not good form though, so fix this by
verifying the IP header checksum early in that function.  If its
checksum is non-zero, the packet will be bad, so just return an
error.  This will cause the packet to passed to the IP layer where
it can be dropped.

Thereafter, there is no need subtract the IP header checksum from
the checksum value in the trailer because we know it is zero.
Add a comment explaining this.

This type of packet error is different from other types, so add a
new statistics counter to track this condition.

Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h b/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h
index 8e64ca98068d908acb82da3afba20e60348d94bf..3d3cba56c516956e2f4f0ff728a3db40437e1b46 100644 (file)
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h
@@ -49,6 +49,7 @@ struct rmnet_pcpu_stats {
 
 struct rmnet_priv_stats {
        u64 csum_ok;
+       u64 csum_ip4_header_bad;
        u64 csum_valid_unset;
        u64 csum_validation_failed;
        u64 csum_err_bad_buffer;

diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c b/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
index 79f1d516b5cca4e6cc4caf0d61b75f0ca0ffa1f0..40d7e0c615f9c177ea9e9906df1345bf06e7395c 100644 (file)
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c
@@ -33,13 +33,21 @@ rmnet_map_ipv4_dl_csum_trailer(struct sk_buff *skb,
                               struct rmnet_map_dl_csum_trailer *csum_trailer,
                               struct rmnet_priv *priv)
 {
-       __sum16 *csum_field, csum_temp, pseudo_csum, hdr_csum, ip_payload_csum;
-       u16 csum_value, csum_value_final;
-       struct iphdr *ip4h;
-       void *txporthdr;
+       struct iphdr *ip4h = (struct iphdr *)skb->data;
+       void *txporthdr = skb->data + ip4h->ihl * 4;
+       __sum16 *csum_field, csum_temp, pseudo_csum;
+       __sum16 ip_payload_csum;
+       u16 csum_value_final;
        __be16 addend;
 
-       ip4h = (struct iphdr *)(skb->data);
+       /* Computing the checksum over just the IPv4 header--including its
+        * checksum field--should yield 0.  If it doesn't, the IP header
+        * is bad, so return an error and let the IP layer drop it.
+        */
+       if (ip_fast_csum(ip4h, ip4h->ihl)) {
+               priv->stats.csum_ip4_header_bad++;
+               return -EINVAL;
+       }
 
        /* We don't support checksum offload on IPv4 fragments */
        if (ip_is_fragment(ip4h)) {
@@ -47,25 +55,30 @@ rmnet_map_ipv4_dl_csum_trailer(struct sk_buff *skb,
                return -EOPNOTSUPP;
        }
 
-       txporthdr = skb->data + ip4h->ihl * 4;
-
+       /* Checksum offload is only supported for UDP and TCP protocols */
        csum_field = rmnet_map_get_csum_field(ip4h->protocol, txporthdr);
-
        if (!csum_field) {
                priv->stats.csum_err_invalid_transport++;
                return -EPROTONOSUPPORT;
        }
 
-       /* RFC 768 - Skip IPv4 UDP packets where sender checksum field is 0 */
-       if (*csum_field == 0 && ip4h->protocol == IPPROTO_UDP) {
+       /* RFC 768: UDP checksum is optional for IPv4, and is 0 if unused */
+       if (!*csum_field && ip4h->protocol == IPPROTO_UDP) {
                priv->stats.csum_skipped++;
                return 0;
        }
 
-       csum_value = ~ntohs(csum_trailer->csum_value);
-       hdr_csum = ~ip_fast_csum(ip4h, (int)ip4h->ihl);
-       ip_payload_csum = csum16_sub((__force __sum16)csum_value,
-                                    (__force __be16)hdr_csum);
+       /* The checksum value in the trailer is computed over the entire
+        * IP packet, including the IP header and payload.  To derive the
+        * transport checksum from this, we first subract the contribution
+        * of the IP header from the trailer checksum.  We then add the
+        * checksum computed over the pseudo header.
+        *
+        * We verified above that the IP header contributes zero to the
+        * trailer checksum.  Therefore the checksum in the trailer is
+        * just the checksum computed over the IP payload.
+        */
+       ip_payload_csum = (__force __sum16)~ntohs(csum_trailer->csum_value);
 
        pseudo_csum = ~csum_tcpudp_magic(ip4h->saddr, ip4h->daddr,
                                         ntohs(ip4h->tot_len) - ip4h->ihl * 4,

diff --git a/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c b/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
index fe13017e9a41e1b87995773e59e27a96c2238b13..6556b5381ce8572bc568eac3c4d4dfde5dad8b6f 100644 (file)
--- a/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
+++ b/drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c
@@ -166,6 +166,7 @@ static const struct net_device_ops rmnet_vnd_ops = {
 
 static const char rmnet_gstrings_stats[][ETH_GSTRING_LEN] = {
        "Checksum ok",
+       "Bad IPv4 header checksum",
        "Checksum valid bit not set",
        "Checksum validation failed",
        "Checksum error bad buffer",