Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * INET An implementation of the TCP/IP protocol suite for the LINUX | |
3 | * operating system. INET is implemented using the BSD Socket | |
4 | * interface as the means of communication with the user level. | |
5 | * | |
6 | * IP/TCP/UDP checksumming routines | |
7 | * | |
8 | * Authors: Jorge Cwik, <jorge@laser.satlink.net> | |
9 | * Arnt Gulbrandsen, <agulbra@nvg.unit.no> | |
10 | * Tom May, <ftom@netcom.com> | |
11 | * Andreas Schwab, <schwab@issan.informatik.uni-dortmund.de> | |
12 | * Lots of code moved from tcp.c and ip.c; see those files | |
13 | * for more names. | |
14 | * | |
15 | * 03/02/96 Jes Sorensen, Andreas Schwab, Roman Hodek: | |
16 | * Fixed some nasty bugs, causing some horrible crashes. | |
17 | * A: At some points, the sum (%0) was used as | |
18 | * length-counter instead of the length counter | |
19 | * (%1). Thanks to Roman Hodek for pointing this out. | |
20 | * B: GCC seems to mess up if one uses too many | |
21 | * data-registers to hold input values and one tries to | |
22 | * specify d0 and d1 as scratch registers. Letting gcc choose these | |
23 | * registers itself solves the problem. | |
24 | * | |
25 | * This program is free software; you can redistribute it and/or | |
26 | * modify it under the terms of the GNU General Public License | |
27 | * as published by the Free Software Foundation; either version | |
28 | * 2 of the License, or (at your option) any later version. | |
29 | */ | |
30 | ||
31 | /* Revised by Kenneth Albanowski for m68knommu. Basic problem: unaligned access kills, so most | |
32 | of the assembly has to go. */ | |
33 | ||
34 | #include <net/checksum.h> | |
40234401 | 35 | #include <linux/module.h> |
1da177e4 LT |
36 | |
37 | static inline unsigned short from32to16(unsigned long x) | |
38 | { | |
39 | /* add up 16-bit and 16-bit for 16+c bit */ | |
40 | x = (x & 0xffff) + (x >> 16); | |
41 | /* add up carry.. */ | |
42 | x = (x & 0xffff) + (x >> 16); | |
43 | return x; | |
44 | } | |
45 | ||
46 | static unsigned long do_csum(const unsigned char * buff, int len) | |
47 | { | |
48 | int odd, count; | |
49 | unsigned long result = 0; | |
50 | ||
51 | if (len <= 0) | |
52 | goto out; | |
53 | odd = 1 & (unsigned long) buff; | |
54 | if (odd) { | |
55 | result = *buff; | |
56 | len--; | |
57 | buff++; | |
58 | } | |
59 | count = len >> 1; /* nr of 16-bit words.. */ | |
60 | if (count) { | |
61 | if (2 & (unsigned long) buff) { | |
62 | result += *(unsigned short *) buff; | |
63 | count--; | |
64 | len -= 2; | |
65 | buff += 2; | |
66 | } | |
67 | count >>= 1; /* nr of 32-bit words.. */ | |
68 | if (count) { | |
69 | unsigned long carry = 0; | |
70 | do { | |
71 | unsigned long w = *(unsigned long *) buff; | |
72 | count--; | |
73 | buff += 4; | |
74 | result += carry; | |
75 | result += w; | |
76 | carry = (w > result); | |
77 | } while (count); | |
78 | result += carry; | |
79 | result = (result & 0xffff) + (result >> 16); | |
80 | } | |
81 | if (len & 2) { | |
82 | result += *(unsigned short *) buff; | |
83 | buff += 2; | |
84 | } | |
85 | } | |
86 | if (len & 1) | |
87 | result += (*buff << 8); | |
88 | result = from32to16(result); | |
89 | if (odd) | |
90 | result = ((result >> 8) & 0xff) | ((result & 0xff) << 8); | |
91 | out: | |
92 | return result; | |
93 | } | |
94 | ||
95 | /* | |
96 | * computes the checksum of a memory block at buff, length len, | |
97 | * and adds in "sum" (32-bit) | |
98 | * | |
99 | * returns a 32-bit number suitable for feeding into itself | |
100 | * or csum_tcpudp_magic | |
101 | * | |
102 | * this function must be called with even lengths, except | |
103 | * for the last fragment, which may be odd | |
104 | * | |
105 | * it's best to have buff aligned on a 32-bit boundary | |
106 | */ | |
8042c44b | 107 | __wsum csum_partial(const void *buff, int len, __wsum sum) |
1da177e4 LT |
108 | { |
109 | unsigned int result = do_csum(buff, len); | |
110 | ||
111 | /* add in old sum, and carry.. */ | |
8042c44b AV |
112 | result += (__force u32)sum; |
113 | if ((__force u32)sum > result) | |
1da177e4 | 114 | result += 1; |
8042c44b | 115 | return (__force __wsum)result; |
1da177e4 LT |
116 | } |
117 | ||
40234401 DH |
118 | EXPORT_SYMBOL(csum_partial); |
119 | ||
1da177e4 LT |
120 | /* |
121 | * this routine is used for miscellaneous IP-like checksums, mainly | |
122 | * in icmp.c | |
123 | */ | |
8042c44b | 124 | __sum16 ip_compute_csum(const void *buff, int len) |
1da177e4 | 125 | { |
8042c44b | 126 | return (__force __sum16)~do_csum(buff, len); |
1da177e4 LT |
127 | } |
128 | ||
40234401 DH |
129 | EXPORT_SYMBOL(ip_compute_csum); |
130 | ||
1da177e4 LT |
131 | /* |
132 | * copy from fs while checksumming, otherwise like csum_partial | |
133 | */ | |
8042c44b AV |
134 | __wsum |
135 | csum_partial_copy_from_user(const void __user *src, void *dst, | |
136 | int len, __wsum sum, int *csum_err) | |
1da177e4 | 137 | { |
40234401 DH |
138 | int rem; |
139 | ||
140 | if (csum_err) | |
141 | *csum_err = 0; | |
142 | ||
143 | rem = copy_from_user(dst, src, len); | |
144 | if (rem != 0) { | |
145 | if (csum_err) | |
146 | *csum_err = -EFAULT; | |
147 | memset(dst + len - rem, 0, rem); | |
148 | len = rem; | |
149 | } | |
150 | ||
1da177e4 LT |
151 | return csum_partial(dst, len, sum); |
152 | } | |
153 | ||
40234401 DH |
154 | EXPORT_SYMBOL(csum_partial_copy_from_user); |
155 | ||
1da177e4 LT |
156 | /* |
157 | * copy from ds while checksumming, otherwise like csum_partial | |
158 | */ | |
8042c44b AV |
159 | __wsum |
160 | csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum) | |
1da177e4 LT |
161 | { |
162 | memcpy(dst, src, len); | |
163 | return csum_partial(dst, len, sum); | |
164 | } | |
40234401 | 165 | |
8042c44b | 166 | EXPORT_SYMBOL(csum_partial_copy_nocheck); |