← Back to branch summary

~ubuntu-branches/debian/experimental/linux-tools/experimental

« back to all changes in this revision

Viewing changes to include/net/sctp/checksum.h

  • Committer: Package Import Robot
  • Author(s): Ben Hutchings
  • Date: 2014-02-02 16:57:49 UTC
  • mfrom: (1.1.10) (0.1.21 sid)
  • Revision ID: package-import@ubuntu.com-20140202165749-tw94o9t1t0a8txk6
Tags: 3.13-1~exp2
Merge changes from sid up to 3.12.6-3

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/net/sctp/checksum.h
42
42
#include <linux/types.h>
43
43
#include <net/sctp/sctp.h>
44
44
#include <linux/crc32c.h>
45
 
 
46
 
static inline __u32 sctp_crc32c(__u32 crc, u8 *buffer, u16 length)
47
 
{
48
 
        return crc32c(crc, buffer, length);
49
 
}
50
 
 
51
 
static inline __u32 sctp_start_cksum(__u8 *buffer, __u16 length)
52
 
{
53
 
        __u32 crc = ~(__u32)0;
54
 
        __u8  zero[sizeof(__u32)] = {0};
55
 
 
56
 
        /* Optimize this routine to be SCTP specific, knowing how
57
 
         * to skip the checksum field of the SCTP header.
 
45
#include <linux/crc32.h>
 
46
 
 
47
static inline __wsum sctp_csum_update(const void *buff, int len, __wsum sum)
 
48
{
 
49
        /* This uses the crypto implementation of crc32c, which is either
 
50
         * implemented w/ hardware support or resolves to __crc32c_le().
58
51
         */
59
 
 
60
 
        /* Calculate CRC up to the checksum. */
61
 
        crc = sctp_crc32c(crc, buffer, sizeof(struct sctphdr) - sizeof(__u32));
62
 
 
63
 
        /* Skip checksum field of the header. */
64
 
        crc = sctp_crc32c(crc, zero, sizeof(__u32));
65
 
 
66
 
        /* Calculate the rest of the CRC. */
67
 
        crc = sctp_crc32c(crc, &buffer[sizeof(struct sctphdr)],
68
 
                            length - sizeof(struct sctphdr));
69
 
        return crc;
70
 
}
71
 
 
72
 
static inline __u32 sctp_update_cksum(__u8 *buffer, __u16 length, __u32 crc32)
73
 
{
74
 
        return sctp_crc32c(crc32, buffer, length);
75
 
}
76
 
 
77
 
static inline __le32 sctp_end_cksum(__u32 crc32)
78
 
{
79
 
        return cpu_to_le32(~crc32);
80
 
}
81
 
 
82
 
/* Calculate the CRC32C checksum of an SCTP packet.  */
 
52
        return crc32c(sum, buff, len);
 
53
}
 
54
 
 
55
static inline __wsum sctp_csum_combine(__wsum csum, __wsum csum2,
 
56
                                       int offset, int len)
 
57
{
 
58
        return __crc32c_le_combine(csum, csum2, len);
 
59
}
 
60
 
83
61
static inline __le32 sctp_compute_cksum(const struct sk_buff *skb,
84
62
                                        unsigned int offset)
85
63
{
86
 
        const struct sk_buff *iter;
87
 
 
88
 
        __u32 crc32 = sctp_start_cksum(skb->data + offset,
89
 
                                       skb_headlen(skb) - offset);
90
 
        skb_walk_frags(skb, iter)
91
 
                crc32 = sctp_update_cksum((__u8 *) iter->data,
92
 
                                          skb_headlen(iter), crc32);
93
 
 
94
 
        return sctp_end_cksum(crc32);
 
64
        struct sctphdr *sh = sctp_hdr(skb);
 
65
        __le32 ret, old = sh->checksum;
 
66
        const struct skb_checksum_ops ops = {
 
67
                .update  = sctp_csum_update,
 
68
                .combine = sctp_csum_combine,
 
69
        };
 
70
 
 
71
        sh->checksum = 0;
 
72
        ret = cpu_to_le32(~__skb_checksum(skb, offset, skb->len - offset,
 
73
                                          ~(__u32)0, &ops));
 
74
        sh->checksum = old;
 
75
 
 
76
        return ret;
95
77
}
96
78
 
97
79
#endif /* __sctp_checksum_h__ */