tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 <asm/checksum.h>
36#include <linux/module.h>
37
38static inline unsigned short from32to16(unsigned long x)
39{
40 /* add up 16-bit and 16-bit for 16+c bit */
41 x = (x & 0xffff) + (x >> 16);
42 /* add up carry.. */
43 x = (x & 0xffff) + (x >> 16);
44 return x;
45}
46
47static unsigned long do_csum(const unsigned char * buff, int len)
48{
49 int odd, count;
50 unsigned long result = 0;
51
52 if (len <= 0)
53 goto out;
54 odd = 1 & (unsigned long) buff;
55 if (odd) {
56 result = *buff;
57 len--;
58 buff++;
59 }
60 count = len >> 1; /* nr of 16-bit words.. */
61 if (count) {
62 if (2 & (unsigned long) buff) {
63 result += *(unsigned short *) buff;
64 count--;
65 len -= 2;
66 buff += 2;
67 }
68 count >>= 1; /* nr of 32-bit words.. */
69 if (count) {
70 unsigned long carry = 0;
71 do {
72 unsigned long w = *(unsigned long *) buff;
73 count--;
74 buff += 4;
75 result += carry;
76 result += w;
77 carry = (w > result);
78 } while (count);
79 result += carry;
80 result = (result & 0xffff) + (result >> 16);
81 }
82 if (len & 2) {
83 result += *(unsigned short *) buff;
84 buff += 2;
85 }
86 }
87 if (len & 1)
88 result += (*buff << 8);
89 result = from32to16(result);
90 if (odd)
91 result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
92out:
93 return result;
94}
95
96/*
97 * computes the checksum of a memory block at buff, length len,
98 * and adds in "sum" (32-bit)
99 *
100 * returns a 32-bit number suitable for feeding into itself
101 * or csum_tcpudp_magic
102 *
103 * this function must be called with even lengths, except
104 * for the last fragment, which may be odd
105 *
106 * it's best to have buff aligned on a 32-bit boundary
107 */
108unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
109{
110 unsigned int result = do_csum(buff, len);
111
112 /* add in old sum, and carry.. */
113 result += sum;
114 if (sum > result)
115 result += 1;
116 return result;
117}
118
119EXPORT_SYMBOL(csum_partial);
120
121/*
122 * this routine is used for miscellaneous IP-like checksums, mainly
123 * in icmp.c
124 */
125unsigned short ip_compute_csum(const unsigned char * buff, int len)
126{
127 return ~do_csum(buff, len);
128}
129
130EXPORT_SYMBOL(ip_compute_csum);
131
132/*
133 * copy from fs while checksumming, otherwise like csum_partial
134 */
135unsigned int
136csum_partial_copy_from_user(const char __user *src, char *dst,
137 int len, int sum, int *csum_err)
138{
139 int rem;
140
141 if (csum_err)
142 *csum_err = 0;
143
144 rem = copy_from_user(dst, src, len);
145 if (rem != 0) {
146 if (csum_err)
147 *csum_err = -EFAULT;
148 memset(dst + len - rem, 0, rem);
149 len = rem;
150 }
151
152 return csum_partial(dst, len, sum);
153}
154
155EXPORT_SYMBOL(csum_partial_copy_from_user);
156
157/*
158 * copy from ds while checksumming, otherwise like csum_partial
159 */
160unsigned int
161csum_partial_copy(const char *src, char *dst, int len, int sum)
162{
163 memcpy(dst, src, len);
164 return csum_partial(dst, len, sum);
165}
166
167EXPORT_SYMBOL(csum_partial_copy);