Add new md5 code to common. Replace cookie generation code.

Remove some dead code from gdm-common.  Set xauth stuff in slave
correctly.  Greeter now starts on xdmcp.

svn path=/branches/mccann-gobject/; revision=4937

5 files changed, 937 insertions, 388 deletions

diff --git a/common/Makefile.am b/common/Makefile.am
index dd9d1218..f28a0e89 100644
--- a/common/Makefile.am
+++ b/common/Makefile.am
@@ -38,6 +38,8 @@ libgdmcommon_a_SOURCES =	\
 	gdm-config.c		\
 	gdm-log.h		\
 	gdm-log.c		\
+	gdm-md5.h		\
+	gdm-md5.c		\
 	gdm-signal-handler.h	\
 	gdm-signal-handler.c	\
 	ve-signal.h		\
diff --git a/common/gdm-common.c b/common/gdm-common.c
index 73e78b9f..c66c026a 100644
--- a/common/gdm-common.c
+++ b/common/gdm-common.c
@@ -40,6 +40,7 @@
 #include <glib/gi18n.h>
 
 #include "gdm-common.h"
+#include "gdm-md5.h"
 
 int
 gdm_fdgetc (int fd)
@@ -314,361 +315,6 @@ gdm_sigusr2_block_pop (void)
 	}
 }
 
-static GdmHostent *
-fillout_addrinfo (struct addrinfo *res,
-		  struct sockaddr *ia,
-		  const char *name)
-{
-	GdmHostent *he;
-	gint i;
-	gint addr_count = 0;
-	struct addrinfo *tempaddrinfo;
-
-	he = g_new0 (GdmHostent, 1);
-
-	he->addrs = NULL;
-	he->addr_count = 0;
-
-	if (res != NULL && res->ai_canonname != NULL) {
-		he->hostname = g_strdup (res->ai_canonname);
-		he->not_found = FALSE;
-	} else {
-		he->not_found = TRUE;
-		if (name != NULL)
-			he->hostname = g_strdup (name);
-		else {
-			static char buffer6[INET6_ADDRSTRLEN];
-			static char buffer[INET_ADDRSTRLEN];
-			const char *new = NULL;
-
-			if (ia->sa_family == AF_INET6) {
-				if (IN6_IS_ADDR_V4MAPPED (&((struct sockaddr_in6 *)ia)->sin6_addr)) {
-					new = inet_ntop (AF_INET, &(((struct sockaddr_in6 *)ia)->sin6_addr.s6_addr[12]), buffer, sizeof (buffer));
-				} else {
-					new = inet_ntop (AF_INET6, &((struct sockaddr_in6 *)ia)->sin6_addr, buffer6, sizeof (buffer6));
-				}
-			} else if (ia->sa_family == AF_INET) {
-				new = inet_ntop (AF_INET, &((struct sockaddr_in *)ia)->sin_addr, buffer, sizeof (buffer));
-			}
-
-			if (new != NULL) {
-				he->hostname = g_strdup (new);
-			} else {
-				he->hostname = NULL;
-			}
-		}
-	}
-
-	tempaddrinfo = res;
-
-	while (res != NULL) {
-		addr_count++;
-		res = res->ai_next;
-	}
-
-	he->addrs = g_new0 (struct sockaddr_storage, addr_count);
-	he->addr_count = addr_count;
-	res = tempaddrinfo;
-	for (i = 0; ; i++) {
-		if (res == NULL)
-			break;
-
-		if ((res->ai_family == AF_INET) || (res->ai_family == AF_INET6)) {
-			(he->addrs)[i] = *(struct sockaddr_storage *)(res->ai_addr);
-		}
-
-		res = res->ai_next;
-	}
-
-	/* We don't want the ::ffff: that could arise here */
-	if (he->hostname != NULL &&
-	    strncmp (he->hostname, "::ffff:", 7) == 0) {
-		strcpy (he->hostname, he->hostname + 7);
-	}
-
-	return he;
-}
-
-/* stolen from xdm sources */
-#if defined(X_NOT_POSIX) || defined(__EMX__) || defined(__NetBSD__) && defined(__sparc__)
-#define Setjmp(e)	setjmp(e)
-#define Longjmp(e,v)	longjmp(e,v)
-#define Jmp_buf		jmp_buf
-#else
-#define Setjmp(e)   sigsetjmp(e,1)
-#define Longjmp(e,v)	siglongjmp(e,v)
-#define Jmp_buf		sigjmp_buf
-#endif
-
-static gboolean do_jumpback = FALSE;
-static Jmp_buf signal_jumpback;
-static struct sigaction oldterm, oldint, oldhup;
-
-static void
-jumpback_sighandler (int signal)
-{
-	/*
-         * This avoids a race see Note below.
-	 * We want to jump back only on the first
-	 * signal invocation, even if the signal
-	 * handler didn't return.
-         */
-	gboolean old_do_jumpback = do_jumpback;
-	do_jumpback = FALSE;
-
-	if (signal == SIGINT)
-		oldint.sa_handler (signal);
-	else if (signal == SIGTERM)
-		oldint.sa_handler (signal);
-	else if (signal == SIGHUP)
-		oldint.sa_handler (signal);
-	/* No others should be set up */
-
-	/* Note that we may not get here since
-	   the SIGTERM handler in slave.c
-	   might have in fact done the big Longjmp
-	   to the slave's death */
-
-	if (old_do_jumpback) {
-		Longjmp (signal_jumpback, 1);
-	}
-}
-
-/*
- * This sets up interruptes to be proxied and the
- * gethostbyname/addr to be whacked using longjmp,
- * in case INT/TERM/HUP was gotten in which case
- * we no longer care for the result of the
- * resolution.
- */
-#define SETUP_INTERRUPTS_FOR_TERM_DECLS \
-    struct sigaction term;
-
-#define SETUP_INTERRUPTS_FOR_TERM_SETUP \
-    do_jumpback = FALSE;						\
-    									\
-    term.sa_handler = jumpback_sighandler;				\
-    term.sa_flags = SA_RESTART;						\
-    sigemptyset (&term.sa_mask);					\
-									\
-    if G_UNLIKELY (sigaction (SIGTERM, &term, &oldterm) < 0) 		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "TERM", g_strerror (errno)); \
-									\
-    if G_UNLIKELY (sigaction (SIGINT, &term, &oldint) < 0)		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "INT", g_strerror (errno)); \
-									\
-    if G_UNLIKELY (sigaction (SIGHUP, &term, &oldhup) < 0) 		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "HUP", g_strerror (errno)); \
-
-#define SETUP_INTERRUPTS_FOR_TERM_TEARDOWN \
-    do_jumpback = FALSE;						\
-									\
-    if G_UNLIKELY (sigaction (SIGTERM, &oldterm, NULL) < 0) 		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "TERM", g_strerror (errno)); \
-									\
-    if G_UNLIKELY (sigaction (SIGINT, &oldint, NULL) < 0) 		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "INT", g_strerror (errno)); \
-									\
-    if G_UNLIKELY (sigaction (SIGHUP, &oldhup, NULL) < 0) 		\
-	g_critical (_("%s: Error setting up %s signal handler: %s"),	\
-		  "SETUP_INTERRUPTS_FOR_TERM", "HUP", g_strerror (errno));
-
-GdmHostent *
-gdm_gethostbyname (const char *name)
-{
-	struct addrinfo hints;
-	/* static because of Setjmp */
-	static struct addrinfo *result;
-
-	SETUP_INTERRUPTS_FOR_TERM_DECLS
-
-	/* The cached address */
-	static GdmHostent *he = NULL;
-	static time_t last_time = 0;
-	static char *cached_hostname = NULL;
-
-	if (cached_hostname != NULL &&
-	    strcmp (cached_hostname, name) == 0) {
-		/* Don't check more then every 60 seconds */
-		if (last_time + 60 > time (NULL))
-			return gdm_hostent_copy (he);
-	}
-
-	SETUP_INTERRUPTS_FOR_TERM_SETUP
-
-	if (Setjmp (signal_jumpback) == 0) {
-		do_jumpback = TRUE;
-
-		/* Find client hostname */
-		memset (&hints, 0, sizeof (hints));
-		hints.ai_socktype = SOCK_DGRAM;
-		hints.ai_flags = AI_CANONNAME;
-
-		if (result) {
-			freeaddrinfo (result);
-			result = NULL;
-		}
-
-		getaddrinfo (name, NULL, &hints, &result);
-		do_jumpback = FALSE;
-	} else {
-               /* Here we got interrupted */
-		result = NULL;
-	}
-
-	SETUP_INTERRUPTS_FOR_TERM_TEARDOWN
-
-	g_free (cached_hostname);
-	cached_hostname = g_strdup (name);
-
-	gdm_hostent_free (he);
-
-	he = fillout_addrinfo (result, NULL, name);
-
-	last_time = time (NULL);
-	return gdm_hostent_copy (he);
-}
-
-GdmHostent *
-gdm_gethostbyaddr (struct sockaddr_storage *ia)
-{
-	struct addrinfo hints;
-	/* static because of Setjmp */
-	static struct addrinfo *result = NULL;
-	struct sockaddr_in6 sin6;
-	struct sockaddr_in sin;
-	static struct in6_addr cached_addr6;
-
-	SETUP_INTERRUPTS_FOR_TERM_DECLS
-
-	/* The cached address */
-	static GdmHostent *he = NULL;
-	static time_t last_time = 0;
-	static struct in_addr cached_addr;
-
-	if (last_time != 0) {
-		if ((ia->ss_family == AF_INET6) && (memcmp (cached_addr6.s6_addr, ((struct sockaddr_in6 *) ia)->sin6_addr.s6_addr, sizeof (struct in6_addr)) == 0)) {
-			/* Don't check more then every 60 seconds */
-			if (last_time + 60 > time (NULL))
-				return gdm_hostent_copy (he);
-		} else if (ia->ss_family == AF_INET) {
-			if (memcmp (&cached_addr, &(((struct sockaddr_in *)ia)->sin_addr), sizeof (struct in_addr)) == 0) {
-				/* Don't check more then every 60 seconds */
-				if (last_time + 60 > time (NULL))
-					return gdm_hostent_copy (he);
-			}
-		}
-	}
-
-	SETUP_INTERRUPTS_FOR_TERM_SETUP
-
-	if (Setjmp (signal_jumpback) == 0) {
-		do_jumpback = TRUE;
-
-		/* Find client hostname */
-		memset (&hints, 0, sizeof (hints));
-		hints.ai_socktype = SOCK_DGRAM;
-		hints.ai_flags = AI_CANONNAME;
-
-		if (result) {
-			freeaddrinfo (result);
-			result = NULL;
-		}
-
-		if (ia->ss_family == AF_INET6) {
-			char buffer6[INET6_ADDRSTRLEN];
-
-			inet_ntop (AF_INET6, &((struct sockaddr_in6 *)ia)->sin6_addr, buffer6, sizeof (buffer6));
-
-			/*
-                         * In the case of IPv6 mapped address strip the
-                         * ::ffff: and lookup as an IPv4 address
-                         */
-			if (strncmp (buffer6, "::ffff:", 7) == 0) {
-				char *temp= (buffer6 + 7);
-				strcpy (buffer6, temp);
-			}
-			getaddrinfo (buffer6, NULL, &hints, &result);
-
-		} else if (ia->ss_family == AF_INET) {
-			char buffer[INET_ADDRSTRLEN];
-
-			inet_ntop (AF_INET, &((struct sockaddr_in *)ia)->sin_addr, buffer, sizeof (buffer));
-
-			getaddrinfo (buffer, NULL, &hints, &result);
-		}
-
-		do_jumpback = FALSE;
-	} else {
-		/* Here we got interrupted */
-		result = NULL;
-	}
-
-	SETUP_INTERRUPTS_FOR_TERM_TEARDOWN
-
-	if (ia->ss_family == AF_INET6) {
-		memcpy (cached_addr6.s6_addr, ((struct sockaddr_in6 *)ia)->sin6_addr.s6_addr, sizeof (struct in6_addr));
-		memset (&sin6, 0, sizeof (sin6));
-		memcpy (sin6.sin6_addr.s6_addr, cached_addr6.s6_addr, sizeof (struct in6_addr));
-		sin6.sin6_family = AF_INET6;
-		he = fillout_addrinfo (result, (struct sockaddr *)&sin6, NULL);
-	}
-	else if (ia->ss_family == AF_INET) {
-		memcpy (&(cached_addr.s_addr), &(((struct sockaddr_in *)ia)->sin_addr.s_addr), sizeof (struct in_addr));
-		memset (&sin, 0, sizeof (sin));
-		memcpy (&sin.sin_addr, &cached_addr, sizeof (struct in_addr));
-		sin.sin_family = AF_INET;
-		he = fillout_addrinfo (result, (struct sockaddr *)&sin, NULL);
-	}
-
-	last_time = time (NULL);
-	return gdm_hostent_copy (he);
-}
-
-GdmHostent *
-gdm_hostent_copy (GdmHostent *he)
-{
-	GdmHostent *cpy;
-
-	if (he == NULL)
-		return NULL;
-
-	cpy = g_new0 (GdmHostent, 1);
-	cpy->not_found = he->not_found;
-	cpy->hostname = g_strdup (he->hostname);
-	if (he->addr_count == 0) {
-		cpy->addr_count = 0;
-		cpy->addrs = NULL;
-	} else {
-		cpy->addr_count = he->addr_count;
-		cpy->addrs = g_new0 (struct sockaddr_storage, he->addr_count);
-		memcpy (cpy->addrs, he->addrs, sizeof (struct sockaddr_storage) * he->addr_count);
-	}
-	return cpy;
-}
-
-void
-gdm_hostent_free (GdmHostent *he)
-{
-	if (he == NULL)
-		return;
-	g_free (he->hostname);
-	he->hostname = NULL;
-
-	g_free (he->addrs);
-	he->addrs = NULL;
-	he->addr_count = 0;
-
-	g_free (he);
-}
-
-
-
 /* Like fopen with "w" */
 FILE *
 gdm_safe_fopen_w (const char *file, mode_t perm)
@@ -916,3 +562,401 @@ ve_locale_exists (const char *loc)
 	g_free (old);
 	return ret;
 }
+
+/* hex conversion adapted from D-Bus */
+
+/**
+ * Appends a two-character hex digit to a string, where the hex digit
+ * has the value of the given byte.
+ *
+ * @param str the string
+ * @param byte the byte
+ */
+static void
+_gdm_string_append_byte_as_hex (GString *str,
+				int      byte)
+{
+	const char hexdigits[16] = {
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+		'a', 'b', 'c', 'd', 'e', 'f'
+	};
+
+	str = g_string_append_c (str, hexdigits[(byte >> 4)]);
+
+	str = g_string_append_c (str, hexdigits[(byte & 0x0f)]);
+}
+
+/**
+ * Encodes a string in hex, the way MD5 and SHA-1 are usually
+ * encoded. (Each byte is two hex digits.)
+ *
+ * @param source the string to encode
+ * @param start byte index to start encoding
+ * @param dest string where encoded data should be placed
+ * @param insert_at where to place encoded data
+ * @returns #TRUE if encoding was successful, #FALSE if no memory etc.
+ */
+gboolean
+gdm_string_hex_encode (const GString *source,
+		       int            start,
+		       GString       *dest,
+		       int            insert_at)
+{
+	GString             *result;
+	const unsigned char *p;
+	const unsigned char *end;
+	gboolean             retval;
+
+	g_assert (start <= source->len);
+
+	result = g_string_new (NULL);
+
+	retval = FALSE;
+
+	p = (const unsigned char*) source->str;
+	end = p + source->len;
+	p += start;
+
+	while (p != end) {
+		_gdm_string_append_byte_as_hex (result, *p);
+		++p;
+	}
+
+	dest = g_string_insert (dest, insert_at, result->str);
+
+	retval = TRUE;
+
+	g_string_free (result, TRUE);
+
+	return retval;
+}
+
+/**
+ * Decodes a string from hex encoding.
+ *
+ * @param source the string to decode
+ * @param start byte index to start decode
+ * @param end_return return location of the end of the hex data, or #NULL
+ * @param dest string where decoded data should be placed
+ * @param insert_at where to place decoded data
+ * @returns #TRUE if decoding was successful, #FALSE if no memory.
+ */
+gboolean
+gdm_string_hex_decode (const GString *source,
+		       int            start,
+		       int           *end_return,
+		       GString       *dest,
+		       int            insert_at)
+{
+	GString             *result;
+	const unsigned char *p;
+	const unsigned char *end;
+	gboolean             retval;
+	gboolean             high_bits;
+
+	g_assert (start <= source->len);
+
+	result = g_string_new (NULL);
+
+	retval = FALSE;
+
+	high_bits = TRUE;
+	p = (const unsigned char*) source->str;
+	end = p + source->len;
+	p += start;
+
+	while (p != end) {
+		unsigned int val;
+
+		switch (*p) {
+		case '0':
+			val = 0;
+			break;
+		case '1':
+			val = 1;
+			break;
+		case '2':
+			val = 2;
+			break;
+		case '3':
+			val = 3;
+			break;
+		case '4':
+			val = 4;
+			break;
+		case '5':
+			val = 5;
+			break;
+		case '6':
+			val = 6;
+			break;
+		case '7':
+			val = 7;
+			break;
+		case '8':
+			val = 8;
+			break;
+		case '9':
+			val = 9;
+			break;
+		case 'a':
+		case 'A':
+			val = 10;
+			break;
+		case 'b':
+		case 'B':
+			val = 11;
+			break;
+		case 'c':
+		case 'C':
+			val = 12;
+			break;
+		case 'd':
+		case 'D':
+			val = 13;
+			break;
+		case 'e':
+		case 'E':
+			val = 14;
+			break;
+		case 'f':
+		case 'F':
+			val = 15;
+			break;
+		default:
+			goto done;
+		}
+
+		if (high_bits) {
+			result = g_string_append_c (result, val << 4);
+		} else {
+			int           len;
+			unsigned char b;
+
+			len = result->len;
+
+			b = result->str[len - 1];
+
+			b |= val;
+
+			result->str[len - 1] = b;
+		}
+
+		high_bits = !high_bits;
+
+		++p;
+	}
+
+ done:
+	dest = g_string_insert (dest, insert_at, result->str);
+
+	if (end_return) {
+		*end_return = p - (const unsigned char*) source->str;
+	}
+
+	retval = TRUE;
+
+	g_string_free (result, TRUE);
+
+	return retval;
+}
+
+static void
+_gdm_generate_pseudorandom_bytes_buffer (char *buffer,
+					 int   n_bytes)
+{
+	int i;
+
+	/* fall back to pseudorandom */
+	g_debug ("Falling back to pseudorandom for %d bytes\n",
+                 n_bytes);
+
+	i = 0;
+	while (i < n_bytes) {
+		int b;
+
+		b = g_random_int_range (0, 255);
+
+		buffer[i] = b;
+
+		++i;
+	}
+}
+
+static gboolean
+_gdm_generate_pseudorandom_bytes (GString *str,
+				  int      n_bytes)
+{
+	int old_len;
+	char *p;
+
+	old_len = str->len;
+
+	str = g_string_set_size (str, old_len + n_bytes);
+
+	p = str->str + old_len;
+
+	_gdm_generate_pseudorandom_bytes_buffer (p, n_bytes);
+
+	return TRUE;
+}
+
+
+static int
+_gdm_fdread (int            fd,
+	     GString       *buffer,
+	     int            count)
+{
+	int   bytes_read;
+	int   start;
+	char *data;
+
+	g_assert (count >= 0);
+
+	start = buffer->len;
+
+	buffer = g_string_set_size (buffer, start + count);
+
+	data = buffer->str + start;
+
+ again:
+	bytes_read = read (fd, data, count);
+
+	if (bytes_read < 0) {
+		if (errno == EINTR) {
+			goto again;
+		} else {
+			/* put length back (note that this doesn't actually realloc anything) */
+			buffer = g_string_set_size (buffer, start);
+			return -1;
+		}
+	} else {
+		/* put length back (doesn't actually realloc) */
+		buffer = g_string_set_size (buffer, start + bytes_read);
+
+		return bytes_read;
+	}
+}
+
+/**
+ * Closes a file descriptor.
+ *
+ * @param fd the file descriptor
+ * @param error error object
+ * @returns #FALSE if error set
+ */
+static gboolean
+_gdm_fdclose (int fd)
+{
+ again:
+	if (close (fd) < 0) {
+		if (errno == EINTR)
+			goto again;
+
+		g_warning ("Could not close fd %d: %s",
+			   fd,
+			   g_strerror (errno));
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Generates the given number of random bytes,
+ * using the best mechanism we can come up with.
+ *
+ * @param str the string
+ * @param n_bytes the number of random bytes to append to string
+ */
+gboolean
+gdm_generate_random_bytes (GString *str,
+			   int      n_bytes)
+{
+	int old_len;
+	int fd;
+
+	/* FALSE return means "no memory", if it could
+	 * mean something else then we'd need to return
+	 * a DBusError. So we always fall back to pseudorandom
+	 * if the I/O fails.
+	 */
+
+	old_len = str->len;
+	fd = -1;
+
+	/* note, urandom on linux will fall back to pseudorandom */
+	fd = g_open ("/dev/urandom", O_RDONLY, 0);
+	if (fd < 0) {
+		return _gdm_generate_pseudorandom_bytes (str, n_bytes);
+	}
+
+	if (_gdm_fdread (fd, str, n_bytes) != n_bytes) {
+		_gdm_fdclose (fd);
+		str = g_string_set_size (str, old_len);
+		return _gdm_generate_pseudorandom_bytes (str, n_bytes);
+	}
+
+	g_debug ("Read %d bytes from /dev/urandom\n", n_bytes);
+
+	_gdm_fdclose (fd);
+
+	return TRUE;
+}
+
+/**
+ * Computes the ASCII hex-encoded md5sum of the given data and
+ * appends it to the output string.
+ *
+ * @param data input data to be hashed
+ * @param ascii_output string to append ASCII md5sum to
+ * @returns #FALSE if not enough memory
+ */
+static gboolean
+gdm_md5_compute (const GString *data,
+		 GString       *ascii_output)
+{
+	GdmMD5Context context;
+	GString      *digest;
+
+	gdm_md5_init (&context);
+
+	gdm_md5_update (&context, data);
+
+	digest = g_string_new (NULL);
+	if (digest == NULL)
+		return FALSE;
+
+	if (! gdm_md5_final (&context, digest))
+		goto error;
+
+	if (! gdm_string_hex_encode (digest,
+				     0,
+				     ascii_output,
+				     ascii_output->len))
+		goto error;
+
+	g_string_free (digest, TRUE);
+
+	return TRUE;
+
+ error:
+	g_string_free (digest, TRUE);
+
+	return FALSE;
+}
+
+gboolean
+gdm_generate_cookie (GString *result)
+{
+	gboolean ret;
+	GString *data;
+
+	data = g_string_new (NULL);
+	gdm_generate_random_bytes (data, 16);
+
+	ret = gdm_md5_compute (data, result);
+	g_string_free (data, TRUE);
+
+	return ret;
+}
diff --git a/common/gdm-common.h b/common/gdm-common.h
index d509271f..66b04bf7 100644
--- a/common/gdm-common.h
+++ b/common/gdm-common.h
@@ -84,42 +84,26 @@ FILE *         gdm_safe_fopen_w  (const char *file,
 FILE *         gdm_safe_fopen_ap (const char *file,
 				  mode_t      perm);
 
-
-typedef struct {
-	gboolean not_found; /* hostname below set to fallback,
-			       as gethostbyaddr/name failed */
-	char *hostname; /* never a bogus dot, if
-			   invalid/unknown, then set to the
-			   ip address in string form */
-
-	struct sockaddr_storage *addrs;
-	int addr_count;
-} GdmHostent;
-
-GdmHostent * gdm_gethostbyname (const char *name);
-
-GdmHostent *gdm_gethostbyaddr (struct sockaddr_storage *ia);
-GdmHostent * gdm_hostent_copy (GdmHostent *he);
-void gdm_hostent_free (GdmHostent *he);
-
 /* This is for race free forks */
-void	gdm_sigchld_block_push (void);
-void	gdm_sigchld_block_pop (void);
-void	gdm_sigterm_block_push (void);
-void	gdm_sigterm_block_pop (void);
-void	gdm_sigusr2_block_push (void);
-void	gdm_sigusr2_block_pop (void);
+void           gdm_sigchld_block_push (void);
+void           gdm_sigchld_block_pop (void);
+void           gdm_sigterm_block_push (void);
+void           gdm_sigterm_block_pop (void);
+void           gdm_sigusr2_block_push (void);
+void           gdm_sigusr2_block_pop (void);
+
+void           gdm_fdprintf  (int fd, const gchar *format, ...) G_GNUC_PRINTF (2, 3);
+int            gdm_fdgetc     (int fd);
+char          *gdm_fdgets   (int fd);
+void           gdm_fd_set_close_on_exec  (int fd);
 
-void gdm_fdprintf  (int fd, const gchar *format, ...) G_GNUC_PRINTF (2, 3);
-int gdm_fdgetc     (int fd);
-char *gdm_fdgets   (int fd);
 
-void gdm_signal_ignore (int signal);
-void gdm_signal_default (int signal);
+void           gdm_signal_ignore (int signal);
+void           gdm_signal_default (int signal);
 
-void gdm_close_all_descriptors (int from, int except, int except2);
+void           gdm_close_all_descriptors (int from, int except, int except2);
 
-int gdm_open_dev_null (mode_t mode);
+int            gdm_open_dev_null (mode_t mode);
 
 /* somewhat like g_build_filename, but does somet hing like
  * <dir> "/" <name> <extension>
@@ -128,8 +112,6 @@ char *         gdm_make_filename (const char *dir,
 				  const char *name,
 				  const char *extension);
 
-void           gdm_fd_set_close_on_exec  (int fd);
-
 void           ve_clearenv (void);
 char *	       ve_first_word (const char *s);
 
@@ -153,6 +135,20 @@ pid_t          ve_waitpid_no_signal (pid_t pid, int *status, int options);
 /* Testing for existance of a certain locale */
 gboolean       ve_locale_exists (const char *loc);
 
+gboolean       gdm_generate_random_bytes (GString *str,
+					  int      n_bytes);
+
+gboolean       gdm_string_hex_encode (const GString *source,
+				      int            start,
+				      GString       *dest,
+				      int            insert_at);
+gboolean       gdm_string_hex_decode (const GString *source,
+				      int            start,
+				      int           *end_return,
+				      GString       *dest,
+				      int            insert_at);
+gboolean       gdm_generate_cookie (GString *result);
+
 G_END_DECLS
 
 #endif /* _GDM_COMMON_H */
diff --git a/common/gdm-md5.c b/common/gdm-md5.c
new file mode 100644
index 00000000..6a676a59
--- /dev/null
+++ b/common/gdm-md5.c
@@ -0,0 +1,457 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * gdm-md5.c md5 implementation (based on L Peter Deutsch implementation)
+ *
+ * Copyright (C) 2003 Red Hat Inc.
+ * Copyright (C) 1999, 2000 Aladdin Enterprises.  All rights reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * L. Peter Deutsch
+ * ghost@aladdin.com
+ */
+/*
+ * Independent implementation of MD5 (RFC 1321).
+ *
+ * This code implements the MD5 Algorithm defined in RFC 1321.
+ * It is derived directly from the text of the RFC and not from the
+ * reference implementation.
+ *
+ * The original and principal author of md5.c is L. Peter Deutsch
+ * <ghost@aladdin.com>.
+ */
+
+/* This GDM version was modified for glib from dbus-md5.c */
+
+#include <string.h>
+#include <glib.h>
+
+#include "gdm-md5.h"
+
+/**
+ * @defgroup GdmMD5Internals MD5 implementation details
+ * @ingroup  GdmInternals
+ * @brief Internals of MD5 implementation.
+ *
+ * The implementation of MD5 (see http://www.ietf.org/rfc/rfc1321.txt).
+ * This MD5 implementation was written by L. Peter Deutsch and
+ * is not derived from the RSA reference implementation in the
+ * RFC. The version included in D-Bus comes from the Ghostscript
+ * 7.05 distribution.
+ *
+ * @{
+ */
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/*
+ * For reference, here is the program that computed the T values.
+ */
+#ifdef COMPUTE_T_VALUES
+#include <math.h>
+int
+main(int argc, char **argv)
+{
+	int i;
+	for (i = 1; i <= 64; ++i)
+		{
+			unsigned long v = (unsigned long)(4294967296.0 * fabs(sin((double)i)));
+
+			/*
+			 * The following nonsense is only to avoid compiler warnings about
+			 * "integer constant is unsigned in ANSI C, signed with -traditional".
+			 */
+			if (v >> 31)
+				{
+					printf("#define T%d /* 0x%08lx */ (T_MASK ^ 0x%08lx)\n", i,
+					       v, (unsigned long)(unsigned int)(~v));
+				} else {
+				printf("#define T%d    0x%08lx\n", i, v);
+			}
+		}
+	return 0;
+}
+#endif /* COMPUTE_T_VALUES */
+/*
+ * End of T computation program.
+ */
+
+#define T_MASK ((guint32)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3    0x242070db
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6    0x4787c62a
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9    0x698098d8
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13    0x6b901122
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16    0x49b40821
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19    0x265e5a51
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22    0x02441453
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25    0x21e1cde6
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28    0x455a14ed
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31    0x676f02d9
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35    0x6d9d6122
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38    0x4bdecfa9
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41    0x289b7ec6
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44    0x04881d05
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47    0x1fa27cf8
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50    0x432aff97
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53    0x655b59c3
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57    0x6fa87e4f
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60    0x4e0811a1
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63    0x2ad7d2bb
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS */
+
+static void
+md5_process (GdmMD5Context *context,
+	     const unsigned char *data /*[64]*/)
+{
+	guint32
+		a = context->abcd[0], b = context->abcd[1],
+		c = context->abcd[2], d = context->abcd[3];
+	guint32 t;
+
+#ifdef WORDS_BIGENDIAN
+	/*
+	 * On big-endian machines, we must arrange the bytes in the right
+	 * order.  (This also works on machines of unknown byte order.)
+	 */
+	guint32 X[16];
+	const unsigned char *xp = data;
+	int i;
+
+	for (i = 0; i < 16; ++i, xp += 4)
+		X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+
+#else  /* !WORDS_BIGENDIAN */
+	/*
+	 * On little-endian machines, we can process properly aligned data
+	 * without copying it.
+	 */
+	guint32 xbuf[16];
+	const guint32 *X;
+
+	if (!((data - (const unsigned char *)0) & 3))
+		{
+			/* data are properly aligned */
+			X = (const guint32 *)data;
+		}
+	else
+		{
+			/* not aligned */
+			memcpy(xbuf, data, 64);
+			X = xbuf;
+		}
+#endif
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+	/* Round 1. */
+	/* Let [abcd k s i] denote the operation
+	   a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)               \
+	t = a + F(b,c,d) + X[k] + Ti;		\
+	a = ROTATE_LEFT(t, s) + b
+	/* Do the following 16 operations. */
+	SET(a, b, c, d,  0,  7,  T1);
+	SET(d, a, b, c,  1, 12,  T2);
+	SET(c, d, a, b,  2, 17,  T3);
+	SET(b, c, d, a,  3, 22,  T4);
+	SET(a, b, c, d,  4,  7,  T5);
+	SET(d, a, b, c,  5, 12,  T6);
+	SET(c, d, a, b,  6, 17,  T7);
+	SET(b, c, d, a,  7, 22,  T8);
+	SET(a, b, c, d,  8,  7,  T9);
+	SET(d, a, b, c,  9, 12, T10);
+	SET(c, d, a, b, 10, 17, T11);
+	SET(b, c, d, a, 11, 22, T12);
+	SET(a, b, c, d, 12,  7, T13);
+	SET(d, a, b, c, 13, 12, T14);
+	SET(c, d, a, b, 14, 17, T15);
+	SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+	/* Round 2. */
+	/* Let [abcd k s i] denote the operation
+	   a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)               \
+	t = a + G(b,c,d) + X[k] + Ti;		\
+	a = ROTATE_LEFT(t, s) + b
+	/* Do the following 16 operations. */
+	SET(a, b, c, d,  1,  5, T17);
+	SET(d, a, b, c,  6,  9, T18);
+	SET(c, d, a, b, 11, 14, T19);
+	SET(b, c, d, a,  0, 20, T20);
+	SET(a, b, c, d,  5,  5, T21);
+	SET(d, a, b, c, 10,  9, T22);
+	SET(c, d, a, b, 15, 14, T23);
+	SET(b, c, d, a,  4, 20, T24);
+	SET(a, b, c, d,  9,  5, T25);
+	SET(d, a, b, c, 14,  9, T26);
+	SET(c, d, a, b,  3, 14, T27);
+	SET(b, c, d, a,  8, 20, T28);
+	SET(a, b, c, d, 13,  5, T29);
+	SET(d, a, b, c,  2,  9, T30);
+	SET(c, d, a, b,  7, 14, T31);
+	SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+	/* Round 3. */
+	/* Let [abcd k s t] denote the operation
+	   a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)               \
+	t = a + H(b,c,d) + X[k] + Ti;		\
+	a = ROTATE_LEFT(t, s) + b
+	/* Do the following 16 operations. */
+	SET(a, b, c, d,  5,  4, T33);
+	SET(d, a, b, c,  8, 11, T34);
+	SET(c, d, a, b, 11, 16, T35);
+	SET(b, c, d, a, 14, 23, T36);
+	SET(a, b, c, d,  1,  4, T37);
+	SET(d, a, b, c,  4, 11, T38);
+	SET(c, d, a, b,  7, 16, T39);
+	SET(b, c, d, a, 10, 23, T40);
+	SET(a, b, c, d, 13,  4, T41);
+	SET(d, a, b, c,  0, 11, T42);
+	SET(c, d, a, b,  3, 16, T43);
+	SET(b, c, d, a,  6, 23, T44);
+	SET(a, b, c, d,  9,  4, T45);
+	SET(d, a, b, c, 12, 11, T46);
+	SET(c, d, a, b, 15, 16, T47);
+	SET(b, c, d, a,  2, 23, T48);
+#undef SET
+
+	/* Round 4. */
+	/* Let [abcd k s t] denote the operation
+	   a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)               \
+	t = a + I(b,c,d) + X[k] + Ti;		\
+	a = ROTATE_LEFT(t, s) + b
+	/* Do the following 16 operations. */
+	SET(a, b, c, d,  0,  6, T49);
+	SET(d, a, b, c,  7, 10, T50);
+	SET(c, d, a, b, 14, 15, T51);
+	SET(b, c, d, a,  5, 21, T52);
+	SET(a, b, c, d, 12,  6, T53);
+	SET(d, a, b, c,  3, 10, T54);
+	SET(c, d, a, b, 10, 15, T55);
+	SET(b, c, d, a,  1, 21, T56);
+	SET(a, b, c, d,  8,  6, T57);
+	SET(d, a, b, c, 15, 10, T58);
+	SET(c, d, a, b,  6, 15, T59);
+	SET(b, c, d, a, 13, 21, T60);
+	SET(a, b, c, d,  4,  6, T61);
+	SET(d, a, b, c, 11, 10, T62);
+	SET(c, d, a, b,  2, 15, T63);
+	SET(b, c, d, a,  9, 21, T64);
+#undef SET
+
+	/* Then perform the following additions. (That is increment each
+	   of the four registers by the value it had before this block
+	   was started.) */
+	context->abcd[0] += a;
+	context->abcd[1] += b;
+	context->abcd[2] += c;
+	context->abcd[3] += d;
+}
+
+static void
+md5_init (GdmMD5Context *context)
+{
+	context->count[0] = context->count[1] = 0;
+	context->abcd[0] = 0x67452301;
+	context->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+	context->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+	context->abcd[3] = 0x10325476;
+}
+
+static void
+md5_append (GdmMD5Context       *context,
+	    const unsigned char *data,
+	    int                  nbytes)
+{
+	const unsigned char *p = data;
+	int left = nbytes;
+	int offset = (context->count[0] >> 3) & 63;
+	guint32 nbits = (guint32)(nbytes << 3);
+
+	if (nbytes <= 0)
+		return;
+
+	/* Update the message length. */
+	context->count[1] += nbytes >> 29;
+	context->count[0] += nbits;
+	if (context->count[0] < nbits)
+		context->count[1]++;
+
+	/* Process an initial partial block. */
+	if (offset)
+		{
+			int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+			memcpy(context->buf + offset, p, copy);
+			if (offset + copy < 64)
+				return;
+			p += copy;
+			left -= copy;
+			md5_process(context, context->buf);
+		}
+
+	/* Process full blocks. */
+	for (; left >= 64; p += 64, left -= 64)
+		md5_process(context, p);
+
+	/* Process a final partial block. */
+	if (left)
+		memcpy(context->buf, p, left);
+}
+
+static void
+md5_finish (GdmMD5Context *context,
+	    unsigned char  digest[16])
+{
+	static const unsigned char pad[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
+	};
+	unsigned char data[8];
+	int i;
+
+	/* Save the length before padding. */
+	for (i = 0; i < 8; ++i)
+		data[i] = (unsigned char)(context->count[i >> 2] >> ((i & 3) << 3));
+	/* Pad to 56 bytes mod 64. */
+	md5_append(context, pad, ((55 - (context->count[0] >> 3)) & 63) + 1);
+	/* Append the length. */
+	md5_append(context, data, 8);
+	for (i = 0; i < 16; ++i)
+		digest[i] = (unsigned char)(context->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+/** @} */ /* End of internals */
+
+/**
+ * @addtogroup GdmMD5
+ *
+ * @{
+ */
+
+/**
+ * Initializes the MD5 context.
+ *
+ * @param context an uninitialized context, typically on the stack.
+ */
+void
+gdm_md5_init (GdmMD5Context *context)
+{
+	md5_init (context);
+}
+
+
+/**
+ * Feeds more data into an existing md5sum computation.
+ *
+ * @param context the MD5 context
+ * @param data the additional data to hash
+ */
+void
+gdm_md5_update (GdmMD5Context *context,
+		const GString *data)
+{
+	unsigned int   inputLen;
+	unsigned char *input;
+
+	input = (unsigned char *)data->str;
+	inputLen = data->len;
+
+	md5_append (context, input, inputLen);
+}
+
+/**
+ * MD5 finalization. Ends an MD5 message-digest operation, writing the
+ * the message digest and zeroing the context.  The results are
+ * returned as a raw 16-byte digest, not as the ascii-hex-digits
+ * string form of the digest.
+ *
+ * @param context the MD5 context
+ * @param results string to append the 16-byte MD5 digest to
+ * @returns #FALSE if not enough memory to append the digest
+ *
+ */
+gboolean
+gdm_md5_final (GdmMD5Context *context,
+	       GString       *results)
+{
+	unsigned char digest[16];
+
+	md5_finish (context, digest);
+
+	if (!g_string_append_len (results, digest, 16))
+		return FALSE;
+
+	/* some kind of security paranoia, though it seems pointless
+	 * to me given the nonzeroed stuff flying around
+	 */
+	memset ((void*)context, '\0', sizeof (GdmMD5Context));
+
+	return TRUE;
+}
diff --git a/common/gdm-md5.h b/common/gdm-md5.h
new file mode 100644
index 00000000..80051f49
--- /dev/null
+++ b/common/gdm-md5.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * gdm-md5.h md5 implementation (based on L Peter Deutsch implementation)
+ *
+ * Copyright (C) 2003 Red Hat Inc.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef GDM_MD5_H
+#define GDM_MD5_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef struct GdmMD5Context GdmMD5Context;
+
+/**
+ * A context used to store the state of the MD5 algorithm
+ */
+struct GdmMD5Context
+{
+	guint32       count[2];       /**< message length in bits, lsw first */
+	guint32       abcd[4];        /**< digest buffer */
+	unsigned char buf[64];        /**< accumulate block */
+};
+
+void        gdm_md5_init    (GdmMD5Context   *context);
+void        gdm_md5_update  (GdmMD5Context   *context,
+			     const GString   *data);
+gboolean    gdm_md5_final   (GdmMD5Context   *context,
+			     GString         *results);
+
+G_END_DECLS
+
+#endif /* GDM_MD5_H */