 @@ -1,43 +1,43 @@
-/*	$NetBSD: sha1.c,v 1.3 2008/02/16 17:37:13 apb Exp $	*/
+/*	$NetBSD: sha1.c,v 1.4 2009/03/16 05:59:21 cegger Exp $	*/
 /*	$OpenBSD: sha1.c,v 1.9 1997/07/23 21:12:32 kstailey Exp $	*/
 /*
  * SHA-1 in C
  * By Steve Reid <steve@edmweb.com>
  * 100% Public Domain
+ *
  * Test Vectors (from FIPS PUB 180-1)
  * "abc"
  *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  * A million repetitions of "a"
  *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
  */
 #define SHA1HANDSOFF		/* Copies data before messing with it. */
 #include <sys/cdefs.h>
 #if defined(_KERNEL) || defined(_STANDALONE)
-__KERNEL_RCSID(0, "$NetBSD: sha1.c,v 1.3 2008/02/16 17:37:13 apb Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sha1.c,v 1.4 2009/03/16 05:59:21 cegger Exp $");
 #include <lib/libkern/libkern.h>
 #else
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: sha1.c,v 1.3 2008/02/16 17:37:13 apb Exp $");
+__RCSID("$NetBSD: sha1.c,v 1.4 2009/03/16 05:59:21 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <assert.h>
 #include <string.h>
 #endif
 #include <sys/types.h>
 #include <sys/sha1.h>
 #if HAVE_NBTOOL_CONFIG_H
 @@ -135,29 +135,27 @@ void
 do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
+{
     nR4(a,b,c,d,e,60); nR4(e,a,b,c,d,61); nR4(d,e,a,b,c,62); nR4(c,d,e,a,b,63);
     nR4(b,c,d,e,a,64); nR4(a,b,c,d,e,65); nR4(e,a,b,c,d,66); nR4(d,e,a,b,c,67);
     nR4(c,d,e,a,b,68); nR4(b,c,d,e,a,69); nR4(a,b,c,d,e,70); nR4(e,a,b,c,d,71);
     nR4(d,e,a,b,c,72); nR4(c,d,e,a,b,73); nR4(b,c,d,e,a,74); nR4(a,b,c,d,e,75);
     nR4(e,a,b,c,d,76); nR4(d,e,a,b,c,77); nR4(c,d,e,a,b,78); nR4(b,c,d,e,a,79);
+}
 #endif
 /*
  * Hash a single 512-bit block. This is the core of the algorithm.
  */
-void SHA1Transform(state, buffer)
+void SHA1Transform(uint32_t state[5], const u_char buffer[64])
     uint32_t state[5];
     const u_char buffer[64];
+{
     uint32_t a, b, c, d, e;
     CHAR64LONG16 *block;
 #ifdef SHA1HANDSOFF
     CHAR64LONG16 workspace;
 #endif
     _DIAGASSERT(buffer != 0);
     _DIAGASSERT(state != 0);
 #ifdef SHA1HANDSOFF
     block = &workspace;
 @@ -207,78 +205,72 @@ void SHA1Transform(state, buffer)
     state[1] += b;
     state[2] += c;
     state[3] += d;
     state[4] += e;
     /* Wipe variables */
     a = b = c = d = e = 0;
+}
 /*
  * SHA1Init - Initialize new context
  */
-void SHA1Init(context)
+void SHA1Init(SHA1_CTX *context)
     SHA1_CTX *context;
+{
     _DIAGASSERT(context != 0);
     /* SHA1 initialization constants */
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
     context->state[4] = 0xC3D2E1F0;
     context->count[0] = context->count[1] = 0;
+}
 /*
  * Run your data through this.
  */
-void SHA1Update(context, data, len)
+void SHA1Update(SHA1_CTX *context, const u_char *data, u_int len)
     SHA1_CTX *context;
     const u_char *data;
     u_int len;
+{
     u_int i, j;
     _DIAGASSERT(context != 0);
     _DIAGASSERT(data != 0);
     j = context->count[0];
     if ((context->count[0] += len << 3) < j)
 	context->count[1] += (len>>29)+1;
     j = (j >> 3) & 63;
     if ((j + len) > 63) {
 	(void)memcpy(&context->buffer[j], data, (i = 64-j));
 	SHA1Transform(context->state, context->buffer);
 	for ( ; i + 63 < len; i += 64)
 	    SHA1Transform(context->state, &data[i]);
 	j = 0;
     } else {
 	i = 0;
+    }
     (void)memcpy(&context->buffer[j], &data[i], len - i);
+}
 /*
  * Add padding and return the message digest.
  */
-void SHA1Final(digest, context)
+void SHA1Final(u_char digest[20], SHA1_CTX *context)
     u_char digest[20];
     SHA1_CTX* context;
+{
     u_int i;
     u_char finalcount[8];
     _DIAGASSERT(digest != 0);
     _DIAGASSERT(context != 0);
     for (i = 0; i < 8; i++) {
 	finalcount[i] = (u_char)((context->count[(i >= 4 ? 0 : 1)]
 	 >> ((3-(i & 3)) * 8) ) & 255);	 /* Endian independent */
+    }
     SHA1Update(context, (const u_char *)"\200", 1);
     while ((context->count[0] & 504) != 448)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: md4c.c,v 1.3 2008/02/16 17:37:13 apb Exp $	*/
+/*	$NetBSD: md4c.c,v 1.4 2009/03/16 05:59:21 cegger Exp $	*/
 /*
  * This file is derived from the RSA Data Security, Inc. MD4 Message-Digest
  * Algorithm and has been modified by Jason R. Thorpe <thorpej@NetBSD.org>
  * for portability and formatting.
  */
 /*
  * Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.
+ *
  * License to copy and use this software is granted provided that it
  * is identified as the "RSA Data Security, Inc. MD4 Message-Digest
  * Algorithm" in all material mentioning or referencing this software
 @@ -21,27 +21,27 @@
+ *
  * RSA Data Security, Inc. makes no representations concerning either
  * the merchantability of this software or the suitability of this
  * software for any particular purpose. It is provided "as is"
  * without express or implied warranty of any kind.
+ *
  * These notices must be retained in any copies of any part of this
  * documentation and/or software.
  */
 #if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: md4c.c,v 1.3 2008/02/16 17:37:13 apb Exp $");
+__RCSID("$NetBSD: md4c.c,v 1.4 2009/03/16 05:59:21 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <sys/types.h>
 #include <assert.h>
 #include <md4.h>
 #include <string.h>
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 @@ -119,51 +119,49 @@ static const unsigned char PADDING[64] =
+}
 #if !defined(_KERNEL) && !defined(_STANDALONE) && defined(__weak_alias)
 __weak_alias(MD4Init,_MD4Init)
 __weak_alias(MD4Update,_MD4Update)
 __weak_alias(MD4Final,_MD4Final)
 __weak_alias(MD4Transform,_MD4Transform)
 #endif
 /*
  * MD4 initialization. Begins an MD4 operation, writing a new context.
  */
 void
-MD4Init(context)
+MD4Init(MD4_CTX *context)		/* context */
 	MD4_CTX *context;		/* context */
+{
 	_DIAGASSERT(context != 0);
 	context->count[0] = context->count[1] = 0;
 	/* Load magic initialization constants. */
 	context->state[0] = 0x67452301;
 	context->state[1] = 0xefcdab89;
 	context->state[2] = 0x98badcfe;
 	context->state[3] = 0x10325476;
+}
 /*
  * MD4 block update operation.  Continues an MD4 message-digest
  * operation, processing another message block, and updating the
  * context.
  */
 void
-MD4Update (context, input, inputLen)
+MD4Update (MD4_CTX *context,		/* context */
-	MD4_CTX *context;		/* context */
+	const unsigned char *input,	/* input block */
-	const unsigned char *input;	/* input block */
+	unsigned int inputLen)		/* length of input block */
 	unsigned int inputLen;		/* length of input block */
+{
 	unsigned int i, idx, partLen;
 	_DIAGASSERT(context != 0);
 	_DIAGASSERT(input != 0);
 	/* Compute number of bytes mod 64 */
 	idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
 	/* Update number of bits */
 	if ((context->count[0] += ((UINT4)inputLen << 3))
 	    < ((UINT4)inputLen << 3))
 		context->count[1]++;
 @@ -182,29 +180,28 @@ MD4Update (context, input, inputLen)
 		idx = 0;
 	} else
 		i = 0;
 	/* Buffer remaining input */
 	memcpy(&context->buffer[idx], &input[i], inputLen - i);
+}
 /*
  * MD4 finalization.  Ends an MD4 message-digest operation, writing the
  * message digest and zeroing the context.
  */
 void
-MD4Final (digest, context)
+MD4Final (unsigned char digest[16],	/* message digest */
-	unsigned char digest[16];	/* message digest */
+	MD4_CTX *context)		/* context */
 	MD4_CTX *context;		/* context */
+{
 	unsigned char bits[8];
 	unsigned int idx, padLen;
 	_DIAGASSERT(digest != 0);
 	_DIAGASSERT(context != 0);
 	/* Save number of bits */
 	Encode(bits, context->count, 8);
 	/* Pad out to 56 mod 64. */
 	idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
 	padLen = (idx < 56) ? (56 - idx) : (120 - idx);
 @@ -214,29 +211,27 @@ MD4Final (digest, context)
 	MD4Update(context, bits, 8);
 	/* Store state in digest */
 	Encode(digest, context->state, 16);
 	/* Zeroize sensitive information. */
 	memset(context, 0, sizeof(*context));
+}
 /*
  * MD4 basic transformation.  Transforms state based on block.
  */
 static void
-MD4Transform (state, block)
+MD4Transform (UINT4 state[4], const unsigned char block[64])
 	UINT4 state[4];
 	const unsigned char block[64];
+{
 	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 	Decode(x, block, 64);
 	/* Round 1 */
 	FF (a, b, c, d, x[ 0], S11); /* 1 */
 	FF (d, a, b, c, x[ 1], S12); /* 2 */
 	FF (c, d, a, b, x[ 2], S13); /* 3 */
 	FF (b, c, d, a, x[ 3], S14); /* 4 */
 	FF (a, b, c, d, x[ 4], S11); /* 5 */
 	FF (d, a, b, c, x[ 5], S12); /* 6 */
 	FF (c, d, a, b, x[ 6], S13); /* 7 */
 @@ -290,46 +285,40 @@ MD4Transform (state, block)
 	state[1] += b;
 	state[2] += c;
 	state[3] += d;
 	/* Zeroize sensitive information. */
 	memset(x, 0, sizeof (x));
+}
 /*
  * Encodes input (UINT4) into output (unsigned char). Assumes len is
  * a multiple of 4.
  */
 static void
-Encode(output, input, len)
+Encode(unsigned char *output, UINT4 *input, unsigned int len)
 	unsigned char *output;
 	UINT4 *input;
 	unsigned int len;
+{
 	unsigned int i, j;
 	for (i = 0, j = 0; j < len; i++, j += 4) {
 		output[j] = (unsigned char)(input[i] & 0xff);
 		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
 /*
  * Decodes input (unsigned char) into output (UINT4). Assumes len is
  * a multiple of 4.
  */
 static void
-Decode(output, input, len)
+Decode(UINT4 *output, const unsigned char *input, unsigned int len)
 	UINT4 *output;
 	const unsigned char *input;
 	unsigned int len;
+{
 	unsigned int i, j;
 	for (i = 0, j = 0; j < len; i++, j += 4)
 		output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 		    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+}
 #endif /* HAVE_MD4_H */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: md5c.c,v 1.3 2008/02/16 17:37:13 apb Exp $	*/
+/*	$NetBSD: md5c.c,v 1.4 2009/03/16 05:59:21 cegger Exp $	*/
 /*
  * This file is derived from the RSA Data Security, Inc. MD5 Message-Digest
  * Algorithm and has been modified by Jason R. Thorpe <thorpej@NetBSD.org>
  * for portability and formatting.
  */
 /*
  * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  * rights reserved.
+ *
  * License to copy and use this software is granted provided that it
  * is identified as the "RSA Data Security, Inc. MD5 Message-Digest
 @@ -26,27 +26,27 @@
  * without express or implied warranty of any kind.
+ *
  * These notices must be retained in any copies of any part of this
  * documentation and/or software.
  */
 #if defined(_KERNEL) || defined(_STANDALONE)
 #include <sys/param.h>
 #include <sys/md5.h>
 #include <lib/libkern/libkern.h>
 #else
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: md5c.c,v 1.3 2008/02/16 17:37:13 apb Exp $");
+__RCSID("$NetBSD: md5c.c,v 1.4 2009/03/16 05:59:21 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <sys/types.h>
 #include <assert.h>
 #include <string.h>
 #include <md5.h>
 #endif /* _KERNEL || _STANDALONE */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #if !HAVE_MD5_H
 @@ -84,50 +84,48 @@ __weak_alias(MD5Final,_MD5Final)
 __weak_alias(MD5Transform,_MD5Transform)
 #endif
 static void MD5Transform __P((UINT4 [4], const unsigned char [64]));
 static void Encode __P((unsigned char *, UINT4 *, unsigned int));
 static void Decode __P((UINT4 *, const unsigned char *, unsigned int));
 /*
  * Encodes input (UINT4) into output (unsigned char).  Assumes len is
  * a multiple of 4.
  */
 static void
-Encode (output, input, len)
+Encode (unsigned char *output,
-	unsigned char *output;
+	UINT4 *input,
-	UINT4 *input;
+	unsigned int len)
 	unsigned int len;
+{
 	unsigned int i, j;
 	for (i = 0, j = 0; j < len; i++, j += 4) {
 		output[j] = (unsigned char)(input[i] & 0xff);
 		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
 /*
  * Decodes input (unsigned char) into output (UINT4).  Assumes len is
  * a multiple of 4.
  */
 static void
-Decode (output, input, len)
+Decode (UINT4 *output,
-	UINT4 *output;
+	const unsigned char *input,
-	const unsigned char *input;
+	unsigned int len)
 	unsigned int len;
+{
 	unsigned int i, j;
 	for (i = 0, j = 0; j < len; i++, j += 4)
 		output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 		    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+}
 static const unsigned char PADDING[64] = {
 x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 @@ -167,51 +165,49 @@ static const unsigned char PADDING[64] =
 	(a) += (b); \
+}
 #define II(a, b, c, d, x, s, ac) { \
 	(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 	(a) = ROTATE_LEFT ((a), (s)); \
 	(a) += (b); \
+}
 /*
  * MD5 initialization. Begins an MD5 operation, writing a new context.
  */
 void
-MD5Init(context)
+MD5Init(MD5_CTX *context)
 	MD5_CTX *context;		/* context */
+{
 	_DIAGASSERT(context != 0);
 	context->count[0] = context->count[1] = 0;
 	/* Load magic initialization constants. */
 	context->state[0] = 0x67452301;
 	context->state[1] = 0xefcdab89;
 	context->state[2] = 0x98badcfe;
 	context->state[3] = 0x10325476;
+}
 /*
  * MD5 block update operation.  Continues an MD5 message-digest
  * operation, processing another message block, and updating the
  * context.
  */
 void
-MD5Update(context, input, inputLen)
+MD5Update(MD5_CTX *context,
-	MD5_CTX *context;		/* context */
+	const unsigned char *input,	/* input block */
-	const unsigned char *input;	/* input block */
+	unsigned int inputLen)		/* length of input block */
 	unsigned int inputLen;		/* length of input block */
+{
 	unsigned int i, idx, partLen;
 	_DIAGASSERT(context != 0);
 	_DIAGASSERT(input != 0);
 	/* Compute number of bytes mod 64 */
 	idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
 	/* Update number of bits */
 	if ((context->count[0] += ((UINT4)inputLen << 3))
 	    < ((UINT4)inputLen << 3))
 		context->count[1]++;
 @@ -230,29 +226,28 @@ MD5Update(context, input, inputLen)
 		idx = 0;
 	} else
 		i = 0;
 	/* Buffer remaining input */
 	memcpy(&context->buffer[idx], &input[i], inputLen - i);
+}
 /*
  * MD5 finalization.  Ends an MD5 message-digest operation, writing the
  * message digest and zeroing the context.
  */
 void
-MD5Final(digest, context)
+MD5Final(unsigned char digest[16],	/* message digest */
-	unsigned char digest[16];	/* message digest */
+	MD5_CTX *context)		/* context */
 	MD5_CTX *context;		/* context */
+{
 	unsigned char bits[8];
 	unsigned int idx, padLen;
 	_DIAGASSERT(digest != 0);
 	_DIAGASSERT(context != 0);
 	/* Save number of bits */
 	Encode(bits, context->count, 8);
 	/* Pad out to 56 mod 64. */
 	idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
 	padLen = (idx < 56) ? (56 - idx) : (120 - idx);
 @@ -262,29 +257,27 @@ MD5Final(digest, context)
 	MD5Update(context, bits, 8);
 	/* Store state in digest */
 	Encode(digest, context->state, 16);
 	/* Zeroize sensitive information. */
 	ZEROIZE((POINTER)(void *)context, sizeof(*context));
+}
 /*
  * MD5 basic transformation. Transforms state based on block.
  */
 static void
-MD5Transform(state, block)
+MD5Transform(UINT4 state[4], const unsigned char block[64])
 	UINT4 state[4];
 	const unsigned char block[64];
+{
 	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 	Decode(x, block, 64);
 	/* Round 1 */
 	FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 	FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 	FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 	FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 	FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 	FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 	FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: __cmsg_alignbytes.c,v 1.2 2008/04/28 20:22:53 martin Exp $	*/
+/*	$NetBSD: __cmsg_alignbytes.c,v 1.3 2009/03/16 05:59:21 cegger Exp $	*/
 /*-
  * Copyright (c) 2000 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jun-ichiro Hagino.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -22,42 +22,42 @@
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: __cmsg_alignbytes.c,v 1.2 2008/04/28 20:22:53 martin Exp $");
+__RCSID("$NetBSD: __cmsg_alignbytes.c,v 1.3 2009/03/16 05:59:21 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/socket.h>
 #else
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/socket.h>
 #endif
 int
-__cmsg_alignbytes()
+__cmsg_alignbytes(void)
+{
 	static int alignbytes = -1;
 #ifdef HW_ALIGNBYTES
 	int mib[2];
 	size_t len;
 	int ret;
 #endif
 	if (alignbytes > 0)
 		return alignbytes;
 #ifdef HW_ALIGNBYTES
 	mib[0] = CTL_HW;

 @@ -1,33 +1,32 @@
-/*  $NetBSD: bswap64.c,v 1.2 2008/02/16 17:37:13 apb Exp $    */
+/*  $NetBSD: bswap64.c,v 1.3 2009/03/16 05:59:21 cegger Exp $    */
 /*
  * Written by Manuel Bouyer <bouyer@NetBSD.org>.
  * Public domain.
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: bswap64.c,v 1.2 2008/02/16 17:37:13 apb Exp $");
+__RCSID("$NetBSD: bswap64.c,v 1.3 2009/03/16 05:59:21 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include <sys/types.h>
 #include <machine/bswap.h>
 #undef bswap64
 uint64_t
-bswap64(x)
+bswap64(uint64_t x)
 	uint64_t x;
+{
 #ifdef _LP64
 	/*
 	 * Assume we have wide enough registers to do it without touching
 	 * memory.
 	 */
 	return  ( (x << 56) & 0xff00000000000000UL ) |
 		( (x << 40) & 0x00ff000000000000UL ) |
 		( (x << 24) & 0x0000ff0000000000UL ) |
 		( (x <<  8) & 0x000000ff00000000UL ) |
 		( (x >>  8) & 0x00000000ff000000UL ) |
 		( (x >> 24) & 0x0000000000ff0000UL ) |
 		( (x >> 40) & 0x000000000000ff00UL ) |