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>
35#include <linux/module.h>
36
37static 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
46static 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);
91out:
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 */
107__wsum csum_partial(const void *buff, int len, __wsum sum)
108{
109	unsigned int result = do_csum(buff, len);
110
111	/* add in old sum, and carry.. */
112	result += (__force u32)sum;
113	if ((__force u32)sum > result)
114		result += 1;
115	return (__force __wsum)result;
116}
117
118EXPORT_SYMBOL(csum_partial);
119
120/*
121 * this routine is used for miscellaneous IP-like checksums, mainly
122 * in icmp.c
123 */
124__sum16 ip_compute_csum(const void *buff, int len)
125{
126	return (__force __sum16)~do_csum(buff, len);
127}
128
129EXPORT_SYMBOL(ip_compute_csum);
130
131/*
132 * copy from fs while checksumming, otherwise like csum_partial
133 */
134__wsum
135csum_partial_copy_from_user(const void __user *src, void *dst,
136			    int len, __wsum sum, int *csum_err)
137{
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
151	return csum_partial(dst, len, sum);
152}
153
154EXPORT_SYMBOL(csum_partial_copy_from_user);
155
156/*
157 * copy from ds while checksumming, otherwise like csum_partial
158 */
159__wsum
160csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum)
161{
162	memcpy(dst, src, len);
163	return csum_partial(dst, len, sum);
164}
165
166EXPORT_SYMBOL(csum_partial_copy_nocheck);
167