* Merged ioq3-r506

* Removed copyfiles rule from Makefile

5 files changed, 187 insertions, 261 deletions

diff --git a/Makefile b/Makefile
index 8a0c89f8..d154a70d 100644
--- a/Makefile
+++ b/Makefile
@@ -1441,21 +1441,6 @@ $(B)/base/qcommon/%.asm: $(CMDIR)/%.c
 # MISC
 #############################################################################
 
-copyfiles: build_release
-	@if [ ! -d $(COPYDIR)/baseq3 ]; then echo "You need to set COPYDIR to where you installed Trem!"; false; fi
-	$(INSTALL) -s -m 0755 $(BR)/tremulous.$(ARCH)$(BINEXT) $(COPYDIR)/tremulous.$(ARCH)$(BINEXT)
-
-	@if [ -f $(BR)/tremded.$(ARCH)$(BINEXT) ]; then \
-		$(INSTALL) -s -m 0755 $(BR)/tremded.$(ARCH)$(BINEXT) $(COPYDIR)/tremded.$(ARCH)$(BINEXT); \
-	fi
-	-$(MKDIR) -p -m 0755 $(COPYDIR)/base
-	$(INSTALL) -s -m 0755 $(BR)/base/cgame$(ARCH).$(SHLIBEXT) \
-					$(COPYDIR)/base/.
-	$(INSTALL) -s -m 0755 $(BR)/base/game$(ARCH).$(SHLIBEXT) \
-					$(COPYDIR)/base/.
-	$(INSTALL) -s -m 0755 $(BR)/base/ui$(ARCH).$(SHLIBEXT) \
-					$(COPYDIR)/base/.
-
 clean:clean-debug clean-release
 	$(MAKE) -C $(MASTERDIR) clean
 
@@ -1472,10 +1457,16 @@ clean-debug:
 clean-release:
 	$(MAKE) clean2 B=$(BR) CFLAGS="$(RELEASE_CFLAGS)"
 
-distclean: clean
+toolsclean:
 	$(MAKE) -C $(TOOLSDIR)/asm clean uninstall
 	$(MAKE) -C $(TOOLSDIR)/lcc clean uninstall
 
+distclean: clean toolsclean
+	rm -rf $(BUILD_DIR)
+
+installer: build_release
+	$(MAKE) VERSION=$(VERSION) -C $(LOKISETUPDIR)
+
 dist:
 	rm -rf tremulous-$(SVN_VERSION)
 	svn export . tremulous-$(SVN_VERSION)
diff --git a/src/client/cl_main.c b/src/client/cl_main.c
index 3f2e1152..093cbc58 100644
--- a/src/client/cl_main.c
+++ b/src/client/cl_main.c
@@ -1988,7 +1988,7 @@ void CL_Frame ( int msec ) {
 	}
 	
 	if( cl_autoRecordDemo->integer ) {
-		if( cls.state == CA_ACTIVE && !clc.demorecording ) {
+		if( cls.state == CA_ACTIVE && !clc.demorecording && !clc.demoplaying ) {
 			// If not recording a demo, and we should be, start one
 			qtime_t	now;
 			char		*nowString;
diff --git a/src/qcommon/files.c b/src/qcommon/files.c
index 4ebca39a..14db75c7 100644
--- a/src/qcommon/files.c
+++ b/src/qcommon/files.c
@@ -1733,7 +1733,8 @@ static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
 
 	buildBuffer = Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len );
 	namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
-	fs_headerLongs = Z_Malloc( gi.number_entry * sizeof(int) );
+	fs_headerLongs = Z_Malloc( ( gi.number_entry + 1 ) * sizeof(int) );
+	fs_headerLongs[ fs_numHeaderLongs++ ] = LittleLong( fs_checksumFeed );
 
 	// get the hash table size from the number of files in the zip
 	// because lots of custom pk3 files have less than 32 or 64 files
@@ -1784,8 +1785,8 @@ static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
 		unzGoToNextFile(uf);
 	}
 
-	pack->checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
-	pack->pure_checksum = Com_BlockChecksumKey( fs_headerLongs, 4 * fs_numHeaderLongs, LittleLong(fs_checksumFeed) );
+	pack->checksum = Com_BlockChecksum( &fs_headerLongs[ 1 ], 4 * ( fs_numHeaderLongs - 1 ) );
+	pack->pure_checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
 	pack->checksum = LittleLong( pack->checksum );
 	pack->pure_checksum = LittleLong( pack->pure_checksum );
 
diff --git a/src/qcommon/md4.c b/src/qcommon/md4.c
index 82c4b0d8..1b491be8 100644
--- a/src/qcommon/md4.c
+++ b/src/qcommon/md4.c
@@ -1,292 +1,227 @@
-/* GLOBAL.H - RSAREF types and constants */
+/*
+	mdfour.c
 
-#include <string.h>
-#ifdef _MSC_VER
-#pragma warning(disable : 4711)		// selected for automatic inline expansion
-#endif
+	An implementation of MD4 designed for use in the samba SMB
+	authentication protocol
 
-/* POINTER defines a generic pointer type */
-typedef unsigned char *POINTER;
-
-/* UINT2 defines a two byte word */
-typedef unsigned short int UINT2;
-
-/* UINT4 defines a four byte word */
-typedef unsigned int UINT4;
-
-  
-/* MD4.H - header file for MD4C.C */
-
-/* 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. MD4 Message-Digest Algorithm” in all material mentioning or referencing this software or this function.
-License is also granted to make and use derivative works provided that such works are identified as “derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm” in all material mentioning or referencing the derived work.
-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. */
-
-/* MD4 context. */
-typedef struct {
-	UINT4 state[4];				/* state (ABCD) */
-	UINT4 count[2];				/* number of bits, modulo 2^64 (lsb first) */
-	unsigned char buffer[64]; 			/* input buffer */
-} MD4_CTX;
-
-void MD4Init (MD4_CTX *);
-void MD4Update (MD4_CTX *, const unsigned char *, unsigned int);
-void MD4Final (unsigned char [16], MD4_CTX *);
-
-#define Com_Memset memset
-#define Com_Memcpy memcpy
-
-/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm */
-/* 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 or this function.
-License is also granted to make and use derivative works provided that such works are identified as 
-derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm
-in all material mentioning or referencing the derived work.
-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. */
-
-/* Constants for MD4Transform routine.  */
-#define S11 3
-#define S12 7
-#define S13 11
-#define S14 19
-#define S21 3
-#define S22 5
-#define S23 9
-#define S24 13
-#define S31 3
-#define S32 9
-#define S33 11
-#define S34 15
-
-static void MD4Transform (UINT4 [4], const unsigned char [64]);
-static void Encode (unsigned char *, UINT4 *, unsigned int);
-static void Decode (UINT4 *, const unsigned char *, unsigned int);
-
-static unsigned char PADDING[64] = {
-0x80, 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, 0, 0
-};
+	Copyright (C) 1997-1998  Andrew Tridgell
 
-/* F, G and H are basic MD4 functions. */
-#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
-#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
-#define H(x, y, z) ((x) ^ (y) ^ (z))
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public License
+	as published by the Free Software Foundation; either version 2
+	of the License, or (at your option) any later version.
 
-/* ROTATE_LEFT rotates x left n bits. */
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
-/* Rotation is separate from addition to prevent recomputation */
-#define FF(a, b, c, d, x, s) {(a) += F ((b), (c), (d)) + (x); (a) = ROTATE_LEFT ((a), (s));}
+	See the GNU General Public License for more details.
 
-#define GG(a, b, c, d, x, s) {(a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; (a) = ROTATE_LEFT ((a), (s));}
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to:
 
-#define HH(a, b, c, d, x, s) {(a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; (a) = ROTATE_LEFT ((a), (s));}
+		Free Software Foundation, Inc.
+		59 Temple Place - Suite 330
+		Boston, MA  02111-1307, USA
 
+	$Id: mdfour.c,v 1.1 2002/08/23 22:03:27 abster Exp $
+*/
 
-/* MD4 initialization. Begins an MD4 operation, writing a new context. */
-void MD4Init (MD4_CTX *context)
-{
-	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;
-}
+#include "q_shared.h"
+#include "qcommon.h"
 
-/* MD4 block update operation. Continues an MD4 message-digest operation, processing another message block, and updating the context. */
-void MD4Update (MD4_CTX *context, const unsigned char *input, unsigned int inputLen)
-{
-	unsigned int i, index, partLen;
+#ifndef int32
+#define int32 int
+#endif
 
-	/* Compute number of bytes mod 64 */
-	index = (unsigned int)((context->count[0] >> 3) & 0x3F);
+#if SIZEOF_INT > 4
+#define LARGE_INT32
+#endif
 
-	/* Update number of bits */
-	if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
-		context->count[1]++;
+#ifndef uint32
+#define uint32 unsigned int32
+#endif
 
-	context->count[1] += ((UINT4)inputLen >> 29);
+struct mdfour {
+	uint32 A, B, C, D;
+	uint32 totalN;
+};
 
-	partLen = 64 - index;
 
-	/* Transform as many times as possible.*/
-	if (inputLen >= partLen)
-	{
- 		Com_Memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
- 		MD4Transform (context->state, context->buffer);
+/* NOTE: This code makes no attempt to be fast!
 
- 		for (i = partLen; i + 63 < inputLen; i += 64)
- 			MD4Transform (context->state, &input[i]);
+   It assumes that a int is at least 32 bits long
+*/
 
- 		index = 0;
-	}
-	else
- 		i = 0;
+static struct mdfour *m;
 
-	/* Buffer remaining input */
-	Com_Memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
-}
+#define F(X,Y,Z) (((X)&(Y)) | ((~(X))&(Z)))
+#define G(X,Y,Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
+#define H(X,Y,Z) ((X)^(Y)^(Z))
+#ifdef LARGE_INT32
+#define lshift(x,s) ((((x)<<(s))&0xFFFFFFFF) | (((x)>>(32-(s)))&0xFFFFFFFF))
+#else
+#define lshift(x,s) (((x)<<(s)) | ((x)>>(32-(s))))
+#endif
 
+#define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s)
+#define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + 0x5A827999,s)
+#define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + 0x6ED9EBA1,s)
 
-/* MD4 finalization. Ends an MD4 message-digest operation, writing the the message digest and zeroizing the context. */
-void MD4Final (unsigned char digest[16], MD4_CTX *context)
+/* this applies md4 to 64 byte chunks */
+static void mdfour64(uint32 *M)
 {
-	unsigned char bits[8];
-	unsigned int index, padLen;
+	int j;
+	uint32 AA, BB, CC, DD;
+	uint32 X[16];
+	uint32 A,B,C,D;
+
+	for (j=0;j<16;j++)
+		X[j] = M[j];
+
+	A = m->A; B = m->B; C = m->C; D = m->D;
+	AA = A; BB = B; CC = C; DD = D;
+
+        ROUND1(A,B,C,D,  0,  3);  ROUND1(D,A,B,C,  1,  7);
+	ROUND1(C,D,A,B,  2, 11);  ROUND1(B,C,D,A,  3, 19);
+        ROUND1(A,B,C,D,  4,  3);  ROUND1(D,A,B,C,  5,  7);
+	ROUND1(C,D,A,B,  6, 11);  ROUND1(B,C,D,A,  7, 19);
+        ROUND1(A,B,C,D,  8,  3);  ROUND1(D,A,B,C,  9,  7);
+	ROUND1(C,D,A,B, 10, 11);  ROUND1(B,C,D,A, 11, 19);
+        ROUND1(A,B,C,D, 12,  3);  ROUND1(D,A,B,C, 13,  7);
+	ROUND1(C,D,A,B, 14, 11);  ROUND1(B,C,D,A, 15, 19);
+
+        ROUND2(A,B,C,D,  0,  3);  ROUND2(D,A,B,C,  4,  5);
+	ROUND2(C,D,A,B,  8,  9);  ROUND2(B,C,D,A, 12, 13);
+        ROUND2(A,B,C,D,  1,  3);  ROUND2(D,A,B,C,  5,  5);
+	ROUND2(C,D,A,B,  9,  9);  ROUND2(B,C,D,A, 13, 13);
+        ROUND2(A,B,C,D,  2,  3);  ROUND2(D,A,B,C,  6,  5);
+	ROUND2(C,D,A,B, 10,  9);  ROUND2(B,C,D,A, 14, 13);
+        ROUND2(A,B,C,D,  3,  3);  ROUND2(D,A,B,C,  7,  5);
+	ROUND2(C,D,A,B, 11,  9);  ROUND2(B,C,D,A, 15, 13);
+
+	ROUND3(A,B,C,D,  0,  3);  ROUND3(D,A,B,C,  8,  9);
+	ROUND3(C,D,A,B,  4, 11);  ROUND3(B,C,D,A, 12, 15);
+        ROUND3(A,B,C,D,  2,  3);  ROUND3(D,A,B,C, 10,  9);
+	ROUND3(C,D,A,B,  6, 11);  ROUND3(B,C,D,A, 14, 15);
+        ROUND3(A,B,C,D,  1,  3);  ROUND3(D,A,B,C,  9,  9);
+	ROUND3(C,D,A,B,  5, 11);  ROUND3(B,C,D,A, 13, 15);
+        ROUND3(A,B,C,D,  3,  3);  ROUND3(D,A,B,C, 11,  9);
+	ROUND3(C,D,A,B,  7, 11);  ROUND3(B,C,D,A, 15, 15);
+
+	A += AA; B += BB; C += CC; D += DD;
+
+#ifdef LARGE_INT32
+	A &= 0xFFFFFFFF; B &= 0xFFFFFFFF;
+	C &= 0xFFFFFFFF; D &= 0xFFFFFFFF;
+#endif
 
-	/* Save number of bits */
-	Encode (bits, context->count, 8);
+	for (j=0;j<16;j++)
+		X[j] = 0;
 
-	/* Pad out to 56 mod 64.*/
-	index = (unsigned int)((context->count[0] >> 3) & 0x3f);
-	padLen = (index < 56) ? (56 - index) : (120 - index);
-	MD4Update (context, PADDING, padLen);
+	m->A = A; m->B = B; m->C = C; m->D = D;
+}
 
-	/* Append length (before padding) */
-	MD4Update (context, bits, 8);
-	
-	/* Store state in digest */
-	Encode (digest, context->state, 16);
+static void copy64(uint32 *M, byte *in)
+{
+	int i;
 
-	/* Zeroize sensitive information.*/
-	Com_Memset ((POINTER)context, 0, sizeof (*context));
+	for (i=0;i<16;i++)
+		M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
+			(in[i*4+1]<<8) | (in[i*4+0]<<0);
 }
 
+static void copy4(byte *out,uint32 x)
+{
+	out[0] = x&0xFF;
+	out[1] = (x>>8)&0xFF;
+	out[2] = (x>>16)&0xFF;
+	out[3] = (x>>24)&0xFF;
+}
 
-/* MD4 basic transformation. Transforms state based on block. */
-static void MD4Transform (UINT4 state[4], const unsigned char block[64])
+void mdfour_begin(struct mdfour *md)
 {
-	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 */
-FF (b, c, d, a, x[ 7], S14); 				/* 8 */
-FF (a, b, c, d, x[ 8], S11); 				/* 9 */
-FF (d, a, b, c, x[ 9], S12); 				/* 10 */
-FF (c, d, a, b, x[10], S13); 			/* 11 */
-FF (b, c, d, a, x[11], S14); 			/* 12 */
-FF (a, b, c, d, x[12], S11); 			/* 13 */
-FF (d, a, b, c, x[13], S12); 			/* 14 */
-FF (c, d, a, b, x[14], S13); 			/* 15 */
-FF (b, c, d, a, x[15], S14); 			/* 16 */
-
-/* Round 2 */
-GG (a, b, c, d, x[ 0], S21); 			/* 17 */
-GG (d, a, b, c, x[ 4], S22); 			/* 18 */
-GG (c, d, a, b, x[ 8], S23); 			/* 19 */
-GG (b, c, d, a, x[12], S24); 			/* 20 */
-GG (a, b, c, d, x[ 1], S21); 			/* 21 */
-GG (d, a, b, c, x[ 5], S22); 			/* 22 */
-GG (c, d, a, b, x[ 9], S23); 			/* 23 */
-GG (b, c, d, a, x[13], S24); 			/* 24 */
-GG (a, b, c, d, x[ 2], S21); 			/* 25 */
-GG (d, a, b, c, x[ 6], S22); 			/* 26 */
-GG (c, d, a, b, x[10], S23); 			/* 27 */
-GG (b, c, d, a, x[14], S24); 			/* 28 */
-GG (a, b, c, d, x[ 3], S21); 			/* 29 */
-GG (d, a, b, c, x[ 7], S22); 			/* 30 */
-GG (c, d, a, b, x[11], S23); 			/* 31 */
-GG (b, c, d, a, x[15], S24); 			/* 32 */
-
-/* Round 3 */
-HH (a, b, c, d, x[ 0], S31);				/* 33 */
-HH (d, a, b, c, x[ 8], S32); 			/* 34 */
-HH (c, d, a, b, x[ 4], S33); 			/* 35 */
-HH (b, c, d, a, x[12], S34); 			/* 36 */
-HH (a, b, c, d, x[ 2], S31); 			/* 37 */
-HH (d, a, b, c, x[10], S32); 			/* 38 */
-HH (c, d, a, b, x[ 6], S33); 			/* 39 */
-HH (b, c, d, a, x[14], S34); 			/* 40 */
-HH (a, b, c, d, x[ 1], S31); 			/* 41 */
-HH (d, a, b, c, x[ 9], S32); 			/* 42 */
-HH (c, d, a, b, x[ 5], S33); 			/* 43 */
-HH (b, c, d, a, x[13], S34); 			/* 44 */
-HH (a, b, c, d, x[ 3], S31); 			/* 45 */
-HH (d, a, b, c, x[11], S32); 			/* 46 */
-HH (c, d, a, b, x[ 7], S33); 			/* 47 */
-HH (b, c, d, a, x[15], S34);			/* 48 */
-
-state[0] += a;
-state[1] += b;
-state[2] += c;
-state[3] += d;
-
-	/* Zeroize sensitive information.*/
-	Com_Memset ((POINTER)x, 0, sizeof (x));
+	md->A = 0x67452301;
+	md->B = 0xefcdab89;
+	md->C = 0x98badcfe;
+	md->D = 0x10325476;
+	md->totalN = 0;
 }
 
 
-/* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */
-static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
+static void mdfour_tail(byte *in, int n)
 {
-	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);
+	byte buf[128];
+	uint32 M[16];
+	uint32 b;
+
+	m->totalN += n;
+
+	b = m->totalN * 8;
+
+	Com_Memset(buf, 0, 128);
+	if (n) Com_Memcpy(buf, in, n);
+	buf[n] = 0x80;
+
+	if (n <= 55) {
+		copy4(buf+56, b);
+		copy64(M, buf);
+		mdfour64(M);
+	} else {
+		copy4(buf+120, b);
+		copy64(M, buf);
+		mdfour64(M);
+		copy64(M, buf+64);
+		mdfour64(M);
 	}
 }
 
-
-/* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */
-static void Decode (UINT4 *output, const unsigned char *input, unsigned int len)
+static void mdfour_update(struct mdfour *md, byte *in, int n)
 {
-unsigned int i, j;
+	uint32 M[16];
+
+	if (n == 0) mdfour_tail(in, n);
 
-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);
+	m = md;
+
+	while (n >= 64) {
+		copy64(M, in);
+		mdfour64(M);
+		in += 64;
+		n -= 64;
+		m->totalN += 64;
+	}
+
+	mdfour_tail(in, n);
 }
 
-//===================================================================
 
-unsigned Com_BlockChecksum (void *buffer, int length)
+static void mdfour_result(struct mdfour *md, byte *out)
 {
-	int			digest[4];
-	unsigned	val;
-	MD4_CTX		ctx;
+	m = md;
 
-	MD4Init (&ctx);
-	MD4Update (&ctx, (unsigned char *)buffer, length);
-	MD4Final ( (unsigned char *)digest, &ctx);
-	
-	val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
+	copy4(out, m->A);
+	copy4(out+4, m->B);
+	copy4(out+8, m->C);
+	copy4(out+12, m->D);
+}
 
-	return val;
+static void mdfour(byte *out, byte *in, int n)
+{
+	struct mdfour md;
+	mdfour_begin(&md);
+	mdfour_update(&md, in, n);
+	mdfour_result(&md, out);
 }
 
-unsigned Com_BlockChecksumKey (void *buffer, int length, int key)
+//===================================================================
+
+unsigned Com_BlockChecksum (const void *buffer, int length)
 {
-	int			digest[4];
+	int				digest[4];
 	unsigned	val;
-	MD4_CTX		ctx;
 
-	MD4Init (&ctx);
-	MD4Update (&ctx, (unsigned char *)&key, 4);
-	MD4Update (&ctx, (unsigned char *)buffer, length);
-	MD4Final ( (unsigned char *)digest, &ctx);
+	mdfour( (byte *)digest, (byte *)buffer, length );
 	
 	val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
 
diff --git a/src/qcommon/qcommon.h b/src/qcommon/qcommon.h
index 9e9ca513..7e14ad11 100644
--- a/src/qcommon/qcommon.h
+++ b/src/qcommon/qcommon.h
@@ -719,7 +719,6 @@ void 		Com_Quit_f( void );
 int			Com_EventLoop( void );
 int			Com_Milliseconds( void );	// will be journaled properly
 unsigned	Com_BlockChecksum( const void *buffer, int length );
-unsigned	Com_BlockChecksumKey (void *buffer, int length, int key);
 int			Com_HashKey(char *string, int maxlen);
 int			Com_Filter(char *filter, char *name, int casesensitive);
 int			Com_FilterPath(char *filter, char *name, int casesensitive);