PageRenderTime 20ms CodeModel.GetById 13ms app.highlight 5ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/h8300/lib/checksum.c

https://bitbucket.org/evzijst/gittest
C | 159 lines | 84 code | 14 blank | 61 comment | 10 complexity | 366f8a5bb41bc4b0280e51eb24a02517 MD5 | raw file
  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 *	This is a version of ip_compute_csum() optimized for IP headers,
 97 *	which always checksum on 4 octet boundaries.
 98 */
 99unsigned short ip_fast_csum(unsigned char * iph, unsigned int ihl)
100{
101	return ~do_csum(iph,ihl*4);
102}
103
104/*
105 * computes the checksum of a memory block at buff, length len,
106 * and adds in "sum" (32-bit)
107 *
108 * returns a 32-bit number suitable for feeding into itself
109 * or csum_tcpudp_magic
110 *
111 * this function must be called with even lengths, except
112 * for the last fragment, which may be odd
113 *
114 * it's best to have buff aligned on a 32-bit boundary
115 */
116unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
117{
118	unsigned int result = do_csum(buff, len);
119
120	/* add in old sum, and carry.. */
121	result += sum;
122	/* 16+c bits -> 16 bits */
123	result = (result & 0xffff) + (result >> 16);
124	return result;
125}
126
127EXPORT_SYMBOL(csum_partial);
128
129/*
130 * this routine is used for miscellaneous IP-like checksums, mainly
131 * in icmp.c
132 */
133unsigned short ip_compute_csum(const unsigned char * buff, int len)
134{
135	return ~do_csum(buff,len);
136}
137
138/*
139 * copy from fs while checksumming, otherwise like csum_partial
140 */
141
142unsigned int
143csum_partial_copy_from_user(const char *src, char *dst, int len, int sum, int *csum_err)
144{
145	if (csum_err) *csum_err = 0;
146	memcpy(dst, src, len);
147	return csum_partial(dst, len, sum);
148}
149
150/*
151 * copy from ds while checksumming, otherwise like csum_partial
152 */
153
154unsigned int
155csum_partial_copy(const char *src, char *dst, int len, int sum)
156{
157	memcpy(dst, src, len);
158	return csum_partial(dst, len, sum);
159}