diff -Naurp open-iscsi/Makefile open-iscsi-5.0.5.595/Makefile

--- open-iscsi/Makefile	2006-05-30 01:51:42.000000000 -0500

+++ open-iscsi-5.0.5.595/Makefile	2006-05-30 02:29:46.000000000 -0500

@@ -26,6 +26,7 @@ ETCFILES = etc/iscsid.conf

 all:

 	$(MAKE) -C usr

 	$(MAKE) -C kernel

+	$(MAKE) -C utils

 	@echo

 	@echo "Compilation complete                Output file"

 	@echo "----------------------------------- ----------------"

@@ -38,6 +39,7 @@ all:

 	@echo Read README file for detailed information.

 clean:

+	$(MAKE) -C utils clean

 	$(MAKE) -C usr clean

 	$(MAKE) -C kernel clean

diff -Naurp open-iscsi/utils/iscsi-iname.c open-iscsi-5.0.5.595/utils/iscsi-iname.c

--- open-iscsi/utils/iscsi-iname.c	1969-12-31 18:00:00.000000000 -0600

+++ open-iscsi-5.0.5.595/utils/iscsi-iname.c	2006-05-30 02:28:34.000000000 -0500

@@ -0,0 +1,140 @@

+/*

+ * iSCSI InitiatorName creation utility

+ * Copyright (C) 2001 Cisco Systems, Inc.

+ * maintained by linux-iscsi-devel@lists.sourceforge.net

+ *

+ * 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.

+ *

+ * 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. See the GNU

+ * General Public License for more details.

+ *

+ * See the file COPYING included with this distribution for more details.

+ *

+ * $Id: iscsi-iname.c,v 1.1.2.3 2005/03/15 06:33:44 wysochanski Exp $

+ *

+ * iscsi-iname.c - Compute an iSCSI InitiatorName for this host.

+ * Note that to ensure uniqueness, the system time is

+ * a factor.  This name must be cached and only regenerated

+ * if there is no cached value.

+ */

+

+#include <stdint.h>

+#include <fcntl.h>

+#include <unistd.h>

+#include <stdlib.h>

+#include <stdio.h>

+#include <string.h>

+#include <sys/utsname.h>

+#include <sys/time.h>

+

+#include "md5.h"

+

+#define RANDOM_NUM_GENERATOR	"/dev/urandom"

+

+int

+main(int argc, char *argv[])

+{

+	char iname[256];

+	struct timeval time;

+	struct utsname system_info;

+	long hostid;

+	struct MD5Context context;

+	unsigned char digest[16];

+	unsigned char *bytes = digest;

+	unsigned char entropy[16];

+	int e;

+	int fd;

+	char *prefix;

+

+	/* initialize */

+	memset(iname, 0, sizeof (iname));

+	memset(digest, 0, sizeof (digest));

+	memset(&context, 0, sizeof (context));

+	MD5Init(&context);

+

+	/* take a prefix if given, otherwise use a default. */

+	if (argc > 1 && argv[1]) {

+		prefix = argv[1];

+		if (( strcmp(prefix, "-h") == 0 ) ||

+		    ( strcmp(prefix, "--help") == 0 )) {

+			printf("\nDisplays the iSCSI initiator name\n");

+			exit(0);

+		} else if ( strcmp(prefix, "-p") == 0 ) {

+			prefix = argv[2];

+		} else {

+			printf("\nUsage: iscsi-iname [-h | --help | "

+			       "-p <prefix>]\n");

+			exit(0);

+		}

+	} else {

+		prefix = "iqn.2005-03.com.redhat:01";

+	}

+

+	/* try to feed some entropy from the pool to MD5 in order to get

+	 * uniqueness properties

+	 */

+

+	if ((fd = open(RANDOM_NUM_GENERATOR, O_RDONLY))) {

+		e = read(fd, &entropy, 16);

+		if (e >= 1)

+			MD5Update(&context, (md5byte *)entropy, e);

+		close(fd);

+	}

+

+	/* time the name is created is a factor in order to get

+	 * uniqueness properties

+	 */

+	if (gettimeofday(&time, NULL) < 0) {

+		perror("error: gettimeofday failed");

+		return 1;

+	}

+	MD5Update(&context, (md5byte *) & time.tv_sec, sizeof (time.tv_sec));

+	MD5Update(&context, (md5byte *) & time.tv_usec, sizeof (time.tv_usec));

+

+	/* hostid */

+	hostid = gethostid();

+	MD5Update(&context, (md5byte *) & hostid, sizeof (hostid));

+

+	/* get the hostname and system name */

+	if (uname(&system_info) < 0) {

+		perror("error: uname failed");

+		return 1;

+	}

+	MD5Update(&context, (md5byte *) system_info.sysname,

+		  sizeof (system_info.sysname));

+	MD5Update(&context, (md5byte *) system_info.nodename,

+		  sizeof (system_info.nodename));

+	MD5Update(&context, (md5byte *) system_info.release,

+		  sizeof (system_info.release));

+	MD5Update(&context, (md5byte *) system_info.version,

+		  sizeof (system_info.version));

+	MD5Update(&context, (md5byte *) system_info.machine,

+		  sizeof (system_info.machine));

+

+	/* compute the md5 hash of all the bits we just collected */

+	MD5Final(digest, &context);

+

+	/* vary which md5 bytes we pick (though we probably don't need to do

+	 * this, since hopefully MD5 produces results such that each byte is as

+	 * good as any other).

+	 */

+

+	if ((fd = open(RANDOM_NUM_GENERATOR, O_RDONLY))) {

+		if (read(fd, entropy, 1) == 1)

+			bytes = &digest[(entropy[0] % (sizeof(digest) - 6))];

+		close(fd);

+	}

+

+	/* print the prefix followed by 6 bytes of the MD5 hash */

+	sprintf(iname, "%s.%x%x%x%x%x%x", prefix,

+		bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]);

+

+	iname[sizeof (iname) - 1] = '\0';

+	printf("%s\n", iname);

+	return 0;

+}

diff -Naurp open-iscsi/utils/Makefile open-iscsi-5.0.5.595/utils/Makefile

--- open-iscsi/utils/Makefile	1969-12-31 18:00:00.000000000 -0600

+++ open-iscsi-5.0.5.595/utils/Makefile	2006-05-30 02:28:34.000000000 -0500

@@ -0,0 +1,12 @@

+# This Makefile will work only with GNU make.

+

+CFLAGS += $(OPTFLAGS) -O2 -fno-inline -Wall -Wstrict-prototypes -g

+PROGRAMS = iscsi-iname

+

+all: $(PROGRAMS)

+

+iscsi-iname: md5.o iscsi-iname.o

+	$(CC) $(CFLAGS) $^ $(DBM_LIB) -o $@

+

+clean:

+	rm -f *.o $(PROGRAMS)

diff -Naurp open-iscsi/utils/md5.c open-iscsi-5.0.5.595/utils/md5.c

--- open-iscsi/utils/md5.c	1969-12-31 18:00:00.000000000 -0600

+++ open-iscsi-5.0.5.595/utils/md5.c	2006-05-30 02:28:34.000000000 -0500

@@ -0,0 +1,242 @@

+/*

+ * This code implements the MD5 message-digest algorithm.

+ * The algorithm is due to Ron Rivest.  This code was

+ * written by Colin Plumb in 1993, no copyright is claimed.

+ * This code is in the public domain; do with it what you wish.

+ *

+ * Equivalent code is available from RSA Data Security, Inc.

+ * This code has been tested against that, and is equivalent,

+ * except that you don't need to include two pages of legalese

+ * with every copy.

+ *

+ * To compute the message digest of a chunk of bytes, declare an

+ * MD5Context structure, pass it to MD5Init, call MD5Update as

+ * needed on buffers full of bytes, and then call MD5Final, which

+ * will fill a supplied 16-byte array with the digest.

+ *

+ * Changed so as no longer to depend on Colin Plumb's `usual.h' header

+ * definitions; now uses stuff from dpkg's config.h.

+ *  - Ian Jackson <ijackson@nyx.cs.du.edu>.

+ * Still in the public domain.

+ */

+

+#include <string.h>

+

+#include "md5.h"

+

+#if (__BYTE_ORDER == __BIG_ENDIAN)

+/*

+ * we can compile this away for little endian since

+ * it does not do anything on those archs

+ */

+void

+byteSwap(uint32_t * buf, unsigned words)

+{

+	md5byte *p = (md5byte *) buf;

+

+	do {

+		*buf++ = (uint32_t) ((unsigned) p[3] << 8 | p[2]) << 16 |

+		    ((unsigned) p[1] << 8 | p[0]);

+		p += 4;

+	} while (--words);

+}

+#else

+#define byteSwap(buf,words)

+#endif

+

+/*

+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious

+ * initialization constants.

+ */

+void

+MD5Init(struct MD5Context *ctx)

+{

+	ctx->buf[0] = 0x67452301;

+	ctx->buf[1] = 0xefcdab89;

+	ctx->buf[2] = 0x98badcfe;

+	ctx->buf[3] = 0x10325476;

+

+	ctx->bytes[0] = 0;

+	ctx->bytes[1] = 0;

+}

+

+/*

+ * Update context to reflect the concatenation of another buffer full

+ * of bytes.

+ */

+void

+MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)

+{

+	uint32_t t;

+

+	/* Update byte count */

+

+	t = ctx->bytes[0];

+	if ((ctx->bytes[0] = t + len) < t)

+		ctx->bytes[1]++;	/* Carry from low to high */

+

+	t = 64 - (t & 0x3f);	/* Space available in ctx->in (at least 1) */

+	if (t > len) {

+		memcpy((md5byte *) ctx->in + 64 - t, buf, len);

+		return;

+	}

+	/* First chunk is an odd size */

+	memcpy((md5byte *) ctx->in + 64 - t, buf, t);

+	byteSwap(ctx->in, 16);

+	MD5Transform(ctx->buf, ctx->in);

+	buf += t;

+	len -= t;

+

+	/* Process data in 64-byte chunks */

+	while (len >= 64) {

+		memcpy(ctx->in, buf, 64);

+		byteSwap(ctx->in, 16);

+		MD5Transform(ctx->buf, ctx->in);

+		buf += 64;

+		len -= 64;

+	}

+

+	/* Handle any remaining bytes of data. */

+	memcpy(ctx->in, buf, len);

+}

+

+/*

+ * Final wrapup - pad to 64-byte boundary with the bit pattern 

+ * 1 0* (64-bit count of bits processed, MSB-first)

+ */

+void

+MD5Final(md5byte digest[16], struct MD5Context *ctx)

+{

+	int count = ctx->bytes[0] & 0x3f;	/* Number of bytes in ctx->in */

+	md5byte *p = (md5byte *) ctx->in + count;

+

+	/* Set the first char of padding to 0x80.  There is always room. */

+	*p++ = 0x80;

+

+	/* Bytes of padding needed to make 56 bytes (-8..55) */

+	count = 56 - 1 - count;

+

+	if (count < 0) {	/* Padding forces an extra block */

+		memset(p, 0, count + 8);

+		byteSwap(ctx->in, 16);

+		MD5Transform(ctx->buf, ctx->in);

+		p = (md5byte *) ctx->in;

+		count = 56;

+	}

+	memset(p, 0, count);

+	byteSwap(ctx->in, 14);

+

+	/* Append length in bits and transform */

+	ctx->in[14] = ctx->bytes[0] << 3;

+	ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;

+	MD5Transform(ctx->buf, ctx->in);

+

+	byteSwap(ctx->buf, 4);

+	memcpy(digest, ctx->buf, 16);

+	memset(ctx, 0, sizeof (ctx));	/* In case it's sensitive */

+}

+

+#ifndef ASM_MD5

+

+/* The four core functions - F1 is optimized somewhat */

+

+/* #define F1(x, y, z) (x & y | ~x & z) */

+#define F1(x, y, z) (z ^ (x & (y ^ z)))

+#define F2(x, y, z) F1(z, x, y)

+#define F3(x, y, z) (x ^ y ^ z)

+#define F4(x, y, z) (y ^ (x | ~z))

+

+/* This is the central step in the MD5 algorithm. */

+#define MD5STEP(f,w,x,y,z,in,s) \

+	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)

+

+/*

+ * The core of the MD5 algorithm, this alters an existing MD5 hash to

+ * reflect the addition of 16 longwords of new data.  MD5Update blocks

+ * the data and converts bytes into longwords for this routine.

+ */

+void

+MD5Transform(uint32_t buf[4], uint32_t const in[16])

+{

+	register uint32_t a, b, c, d;

+

+	a = buf[0];

+	b = buf[1];

+	c = buf[2];

+	d = buf[3];

+

+	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);

+	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);

+	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);

+	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);

+	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);

+	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);

+	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);

+	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);

+	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);

+	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);

+	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);

+	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);

+	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);

+	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);

+	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);

+	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);

+

+	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);

+	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);

+	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);

+	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);

+	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);

+	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);

+	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);

+	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);

+	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);

+	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);

+	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);

+	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);

+	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);

+	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);

+	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);

+	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);

+

+	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);

+	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);

+	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);

+	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);

+	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);

+	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);

+	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);

+	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);

+	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);

+	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);

+	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);

+	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);

+	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);

+	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);

+	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);

+	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);

+

+	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);

+	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);

+	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);

+	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);

+	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);

+	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);

+	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);

+	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);

+	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);

+	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);

+	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);

+	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);

+	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);

+	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);

+	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);

+	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);

+

+	buf[0] += a;

+	buf[1] += b;

+	buf[2] += c;

+	buf[3] += d;

+}

+

+#endif

diff -Naurp open-iscsi/utils/md5.h open-iscsi-5.0.5.595/utils/md5.h

--- open-iscsi/utils/md5.h	1969-12-31 18:00:00.000000000 -0600

+++ open-iscsi-5.0.5.595/utils/md5.h	2006-05-30 02:28:34.000000000 -0500

@@ -0,0 +1,41 @@

+/*

+ * This is the header file for the MD5 message-digest algorithm.

+ * The algorithm is due to Ron Rivest.  This code was

+ * written by Colin Plumb in 1993, no copyright is claimed.

+ * This code is in the public domain; do with it what you wish.

+ *

+ * Equivalent code is available from RSA Data Security, Inc.

+ * This code has been tested against that, and is equivalent,

+ * except that you don't need to include two pages of legalese

+ * with every copy.

+ *

+ * To compute the message digest of a chunk of bytes, declare an

+ * MD5Context structure, pass it to MD5Init, call MD5Update as

+ * needed on buffers full of bytes, and then call MD5Final, which

+ * will fill a supplied 16-byte array with the digest.

+ *

+ * Changed so as no longer to depend on Colin Plumb's `usual.h'

+ * header definitions; now uses stuff from dpkg's config.h

+ *  - Ian Jackson <ijackson@nyx.cs.du.edu>.

+ * Still in the public domain.

+ */

+

+#ifndef MD5_H

+#define MD5_H

+

+#include <stdint.h>

+

+#define md5byte unsigned char

+

+struct MD5Context {

+	uint32_t buf[4];

+	uint32_t bytes[2];

+	uint32_t in[16];

+};

+

+void MD5Init(struct MD5Context *context);

+void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);

+void MD5Final(unsigned char digest[16], struct MD5Context *context);

+void MD5Transform(uint32_t buf[4], uint32_t const in[16]);

+

+#endif				/* !MD5_H */