diff -rupN qemu-0.9.0.orig/configure qemu-0.9.0.new/configure

--- qemu-0.9.0.orig/configure	2007-02-05 18:01:54.000000000 -0500

+++ qemu-0.9.0.new/configure	2007-08-27 13:35:29.000000000 -0400

@@ -86,6 +86,7 @@ alsa="no"

 fmod="no"

 fmod_lib=""

 fmod_inc=""

+vnc_tls="yes"

 bsd="no"

 linux="no"

 kqemu="no"

@@ -224,6 +225,8 @@ for opt do

   ;;

   --fmod-inc=*) fmod_inc="$optarg"

   ;;

+  --disable-vnc-tls) vnc_tls="no"

+  ;;

   --enable-mingw32) mingw32="yes" ; cross_prefix="i386-mingw32-" ; user="no"

   ;;

   --disable-slirp) slirp="no"

@@ -293,6 +296,7 @@ echo "  --enable-coreaudio       enable 

 echo "  --enable-alsa            enable ALSA audio driver"

 echo "  --enable-fmod            enable FMOD audio driver"

 echo "  --enabled-dsound         enable DirectSound audio driver"

+echo "  --disable-vnc-tls        disable TLS encryption for VNC server"

 echo "  --enable-system          enable all system emulation targets"

 echo "  --disable-system         disable all system emulation targets"

 echo "  --enable-linux-user      enable all linux usermode emulation targets"

@@ -538,6 +542,16 @@ else

 fi # -z $sdl

 ##########################################

+# VNC TLS detection

+if test "$vnc_tls" = "yes" ; then

+  `pkg-config gnutls` || vnc_tls="no"

+fi

+if test "$vnc_tls" = "yes" ; then

+  vnc_tls_cflags=`pkg-config --cflags gnutls`

+  vnc_tls_libs=`pkg-config --libs gnutls`

+fi

+

+##########################################

 # alsa sound support libraries

 if test "$alsa" = "yes" ; then

@@ -622,6 +636,11 @@ else

     fmod_support=""

 fi

 echo "FMOD support      $fmod $fmod_support"

+echo "VNC TLS support   $vnc_tls"

+if test "$vnc_tls" = "yes" ; then

+    echo "    TLS CFLAGS    $vnc_tls_cflags"

+    echo "    TLS LIBS      $vnc_tls_libs"

+fi

 echo "kqemu support     $kqemu"

 echo "Documentation     $build_docs"

 [ ! -z "$uname_release" ] && \

@@ -765,6 +784,12 @@ if test "$fmod" = "yes" ; then

   echo "CONFIG_FMOD_INC=$fmod_inc" >> $config_mak

   echo "#define CONFIG_FMOD 1" >> $config_h

 fi

+if test "$vnc_tls" = "yes" ; then

+  echo "CONFIG_VNC_TLS=yes" >> $config_mak

+  echo "CONFIG_VNC_TLS_CFLAGS=$vnc_tls_cflags" >> $config_mak

+  echo "CONFIG_VNC_TLS_LIBS=$vnc_tls_libs" >> $config_mak

+  echo "#define CONFIG_VNC_TLS 1" >> $config_h

+fi

 qemu_version=`head $source_path/VERSION`

 echo "VERSION=$qemu_version" >>$config_mak

 echo "#define QEMU_VERSION \"$qemu_version\"" >> $config_h

diff -rupN qemu-0.9.0.orig/d3des.c qemu-0.9.0.new/d3des.c

--- qemu-0.9.0.orig/d3des.c	1969-12-31 19:00:00.000000000 -0500

+++ qemu-0.9.0.new/d3des.c	2007-08-27 13:29:22.000000000 -0400

@@ -0,0 +1,434 @@

+/*

+ * This is D3DES (V5.09) by Richard Outerbridge with the double and

+ * triple-length support removed for use in VNC.  Also the bytebit[] array

+ * has been reversed so that the most significant bit in each byte of the

+ * key is ignored, not the least significant.

+ *

+ * These changes are:

+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.

+ *

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

+ */

+

+/* D3DES (V5.09) -

+ *

+ * A portable, public domain, version of the Data Encryption Standard.

+ *

+ * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.

+ * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation

+ * code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis

+ * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,

+ * for humouring me on.

+ *

+ * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.

+ * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.

+ */

+

+#include "d3des.h"

+

+static void scrunch(unsigned char *, unsigned long *);

+static void unscrun(unsigned long *, unsigned char *);

+static void desfunc(unsigned long *, unsigned long *);

+static void cookey(unsigned long *);

+

+static unsigned long KnL[32] = { 0L };

+

+static unsigned short bytebit[8]	= {

+	01, 02, 04, 010, 020, 040, 0100, 0200 };

+

+static unsigned long bigbyte[24] = {

+	0x800000L,	0x400000L,	0x200000L,	0x100000L,

+	0x80000L,	0x40000L,	0x20000L,	0x10000L,

+	0x8000L,	0x4000L,	0x2000L,	0x1000L,

+	0x800L, 	0x400L, 	0x200L, 	0x100L,

+	0x80L,		0x40L,		0x20L,		0x10L,

+	0x8L,		0x4L,		0x2L,		0x1L	};

+

+/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */

+

+static unsigned char pc1[56] = {

+	56, 48, 40, 32, 24, 16,  8,	 0, 57, 49, 41, 33, 25, 17,

+	 9,  1, 58, 50, 42, 34, 26,	18, 10,  2, 59, 51, 43, 35,

+	62, 54, 46, 38, 30, 22, 14,	 6, 61, 53, 45, 37, 29, 21,

+	13,  5, 60, 52, 44, 36, 28,	20, 12,  4, 27, 19, 11,  3 };

+

+static unsigned char totrot[16] = {

+	1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };

+

+static unsigned char pc2[48] = {

+	13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,

+	22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,

+	40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,

+	43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };

+

+void deskey(key, edf)	/* Thanks to James Gillogly & Phil Karn! */

+unsigned char *key;

+int edf;

+{

+	register int i, j, l, m, n;

+	unsigned char pc1m[56], pcr[56];

+	unsigned long kn[32];

+

+	for ( j = 0; j < 56; j++ ) {

+		l = pc1[j];

+		m = l & 07;

+		pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;

+		}

+	for( i = 0; i < 16; i++ ) {

+		if( edf == DE1 ) m = (15 - i) << 1;

+		else m = i << 1;

+		n = m + 1;

+		kn[m] = kn[n] = 0L;

+		for( j = 0; j < 28; j++ ) {

+			l = j + totrot[i];

+			if( l < 28 ) pcr[j] = pc1m[l];

+			else pcr[j] = pc1m[l - 28];

+			}

+		for( j = 28; j < 56; j++ ) {

+		    l = j + totrot[i];

+		    if( l < 56 ) pcr[j] = pc1m[l];

+		    else pcr[j] = pc1m[l - 28];

+		    }

+		for( j = 0; j < 24; j++ ) {

+			if( pcr[pc2[j]] ) kn[m] |= bigbyte[j];

+			if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j];

+			}

+		}

+	cookey(kn);

+	return;

+	}

+

+static void cookey(raw1)

+register unsigned long *raw1;

+{

+	register unsigned long *cook, *raw0;

+	unsigned long dough[32];

+	register int i;

+

+	cook = dough;

+	for( i = 0; i < 16; i++, raw1++ ) {

+		raw0 = raw1++;

+		*cook	 = (*raw0 & 0x00fc0000L) << 6;

+		*cook	|= (*raw0 & 0x00000fc0L) << 10;

+		*cook	|= (*raw1 & 0x00fc0000L) >> 10;

+		*cook++ |= (*raw1 & 0x00000fc0L) >> 6;

+		*cook	 = (*raw0 & 0x0003f000L) << 12;

+		*cook	|= (*raw0 & 0x0000003fL) << 16;

+		*cook	|= (*raw1 & 0x0003f000L) >> 4;

+		*cook++ |= (*raw1 & 0x0000003fL);

+		}

+	usekey(dough);

+	return;

+	}

+

+void cpkey(into)

+register unsigned long *into;

+{

+	register unsigned long *from, *endp;

+

+	from = KnL, endp = &KnL[32];

+	while( from < endp ) *into++ = *from++;

+	return;

+	}

+

+void usekey(from)

+register unsigned long *from;

+{

+	register unsigned long *to, *endp;

+

+	to = KnL, endp = &KnL[32];

+	while( to < endp ) *to++ = *from++;

+	return;

+	}

+

+void des(inblock, outblock)

+unsigned char *inblock, *outblock;

+{

+	unsigned long work[2];

+

+	scrunch(inblock, work);

+	desfunc(work, KnL);

+	unscrun(work, outblock);

+	return;

+	}

+

+static void scrunch(outof, into)

+register unsigned char *outof;

+register unsigned long *into;

+{

+	*into	 = (*outof++ & 0xffL) << 24;

+	*into	|= (*outof++ & 0xffL) << 16;

+	*into	|= (*outof++ & 0xffL) << 8;

+	*into++ |= (*outof++ & 0xffL);

+	*into	 = (*outof++ & 0xffL) << 24;

+	*into	|= (*outof++ & 0xffL) << 16;

+	*into	|= (*outof++ & 0xffL) << 8;

+	*into	|= (*outof   & 0xffL);

+	return;

+	}

+

+static void unscrun(outof, into)

+register unsigned long *outof;

+register unsigned char *into;

+{

+	*into++ = (unsigned char)((*outof >> 24) & 0xffL);

+	*into++ = (unsigned char)((*outof >> 16) & 0xffL);

+	*into++ = (unsigned char)((*outof >>  8) & 0xffL);

+	*into++ = (unsigned char)(*outof++	 & 0xffL);

+	*into++ = (unsigned char)((*outof >> 24) & 0xffL);

+	*into++ = (unsigned char)((*outof >> 16) & 0xffL);

+	*into++ = (unsigned char)((*outof >>  8) & 0xffL);

+	*into	=  (unsigned char)(*outof	 & 0xffL);

+	return;

+	}

+

+static unsigned long SP1[64] = {

+	0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,

+	0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,

+	0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,

+	0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,

+	0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,

+	0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,

+	0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,

+	0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,

+	0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,

+	0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,

+	0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,

+	0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,

+	0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,

+	0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,

+	0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,

+	0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };

+

+static unsigned long SP2[64] = {

+	0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,

+	0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,

+	0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,

+	0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,

+	0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,

+	0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,

+	0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,

+	0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,

+	0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,

+	0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,

+	0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,

+	0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,

+	0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,

+	0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,

+	0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,

+	0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };

+

+static unsigned long SP3[64] = {

+	0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,

+	0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,

+	0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,

+	0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,

+	0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,

+	0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,

+	0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,

+	0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,

+	0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,

+	0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,

+	0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,

+	0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,

+	0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,

+	0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,

+	0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,

+	0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };

+

+static unsigned long SP4[64] = {

+	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,

+	0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,

+	0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,

+	0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,

+	0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,

+	0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,

+	0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,

+	0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,

+	0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,

+	0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,

+	0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,

+	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,

+	0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,

+	0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,

+	0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,

+	0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };

+

+static unsigned long SP5[64] = {

+	0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,

+	0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,

+	0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,

+	0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,

+	0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,

+	0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,

+	0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,

+	0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,

+	0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,

+	0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,

+	0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,

+	0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,

+	0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,

+	0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,

+	0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,

+	0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };

+

+static unsigned long SP6[64] = {

+	0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,

+	0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,

+	0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,

+	0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,

+	0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,

+	0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,

+	0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,

+	0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,

+	0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,

+	0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,

+	0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,

+	0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,

+	0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,

+	0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,

+	0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,

+	0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };

+

+static unsigned long SP7[64] = {

+	0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,

+	0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,

+	0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,

+	0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,

+	0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,

+	0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,

+	0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,

+	0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,

+	0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,

+	0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,

+	0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,

+	0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,

+	0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,

+	0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,

+	0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,

+	0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };

+

+static unsigned long SP8[64] = {

+	0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,

+	0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,

+	0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,

+	0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,

+	0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,

+	0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,

+	0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,

+	0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,

+	0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,

+	0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,

+	0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,

+	0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,

+	0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,

+	0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,

+	0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,

+	0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };

+

+static void desfunc(block, keys)

+register unsigned long *block, *keys;

+{

+	register unsigned long fval, work, right, leftt;

+	register int round;

+

+	leftt = block[0];

+	right = block[1];

+	work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;

+	right ^= work;

+	leftt ^= (work << 4);

+	work = ((leftt >> 16) ^ right) & 0x0000ffffL;

+	right ^= work;

+	leftt ^= (work << 16);

+	work = ((right >> 2) ^ leftt) & 0x33333333L;

+	leftt ^= work;

+	right ^= (work << 2);

+	work = ((right >> 8) ^ leftt) & 0x00ff00ffL;

+	leftt ^= work;

+	right ^= (work << 8);

+	right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;

+	work = (leftt ^ right) & 0xaaaaaaaaL;

+	leftt ^= work;

+	right ^= work;

+	leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;

+

+	for( round = 0; round < 8; round++ ) {

+		work  = (right << 28) | (right >> 4);

+		work ^= *keys++;

+		fval  = SP7[ work		 & 0x3fL];

+		fval |= SP5[(work >>  8) & 0x3fL];

+		fval |= SP3[(work >> 16) & 0x3fL];

+		fval |= SP1[(work >> 24) & 0x3fL];

+		work  = right ^ *keys++;

+		fval |= SP8[ work		 & 0x3fL];

+		fval |= SP6[(work >>  8) & 0x3fL];

+		fval |= SP4[(work >> 16) & 0x3fL];

+		fval |= SP2[(work >> 24) & 0x3fL];

+		leftt ^= fval;

+		work  = (leftt << 28) | (leftt >> 4);

+		work ^= *keys++;

+		fval  = SP7[ work		 & 0x3fL];

+		fval |= SP5[(work >>  8) & 0x3fL];

+		fval |= SP3[(work >> 16) & 0x3fL];

+		fval |= SP1[(work >> 24) & 0x3fL];

+		work  = leftt ^ *keys++;

+		fval |= SP8[ work		 & 0x3fL];

+		fval |= SP6[(work >>  8) & 0x3fL];

+		fval |= SP4[(work >> 16) & 0x3fL];

+		fval |= SP2[(work >> 24) & 0x3fL];

+		right ^= fval;

+		}

+

+	right = (right << 31) | (right >> 1);

+	work = (leftt ^ right) & 0xaaaaaaaaL;

+	leftt ^= work;

+	right ^= work;

+	leftt = (leftt << 31) | (leftt >> 1);

+	work = ((leftt >> 8) ^ right) & 0x00ff00ffL;

+	right ^= work;

+	leftt ^= (work << 8);

+	work = ((leftt >> 2) ^ right) & 0x33333333L;

+	right ^= work;

+	leftt ^= (work << 2);

+	work = ((right >> 16) ^ leftt) & 0x0000ffffL;

+	leftt ^= work;

+	right ^= (work << 16);

+	work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;

+	leftt ^= work;

+	right ^= (work << 4);

+	*block++ = right;

+	*block = leftt;

+	return;

+	}

+

+/* Validation sets:

+ *

+ * Single-length key, single-length plaintext -

+ * Key	  : 0123 4567 89ab cdef

+ * Plain  : 0123 4567 89ab cde7

+ * Cipher : c957 4425 6a5e d31d

+ *

+ * Double-length key, single-length plaintext -

+ * Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210

+ * Plain  : 0123 4567 89ab cde7

+ * Cipher : 7f1d 0a77 826b 8aff

+ *

+ * Double-length key, double-length plaintext -

+ * Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210

+ * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff

+ * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7

+ *

+ * Triple-length key, single-length plaintext -

+ * Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

+ * Plain  : 0123 4567 89ab cde7

+ * Cipher : de0b 7c06 ae5e 0ed5

+ *

+ * Triple-length key, double-length plaintext -

+ * Key	  : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567

+ * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff

+ * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5

+ *

+ * d3des V5.0a rwo 9208.07 18:44 Graven Imagery

+ **********************************************************************/

diff -rupN qemu-0.9.0.orig/d3des.h qemu-0.9.0.new/d3des.h

--- qemu-0.9.0.orig/d3des.h	1969-12-31 19:00:00.000000000 -0500

+++ qemu-0.9.0.new/d3des.h	2007-08-27 13:29:22.000000000 -0400

@@ -0,0 +1,51 @@

+/*

+ * This is D3DES (V5.09) by Richard Outerbridge with the double and

+ * triple-length support removed for use in VNC.

+ *

+ * These changes are:

+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.

+ *

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

+ */

+

+/* d3des.h -

+ *

+ *	Headers and defines for d3des.c

+ *	Graven Imagery, 1992.

+ *

+ * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge

+ *	(GEnie : OUTER; CIS : [71755,204])

+ */

+

+#define EN0	0	/* MODE == encrypt */

+#define DE1	1	/* MODE == decrypt */

+

+extern void deskey(unsigned char *, int);

+/*		      hexkey[8]     MODE

+ * Sets the internal key register according to the hexadecimal

+ * key contained in the 8 bytes of hexkey, according to the DES,

+ * for encryption or decryption according to MODE.

+ */

+

+extern void usekey(unsigned long *);

+/*		    cookedkey[32]

+ * Loads the internal key register with the data in cookedkey.

+ */

+

+extern void cpkey(unsigned long *);

+/*		   cookedkey[32]

+ * Copies the contents of the internal key register into the storage

+ * located at &cookedkey[0].

+ */

+

+extern void des(unsigned char *, unsigned char *);

+/*		    from[8]	      to[8]

+ * Encrypts/Decrypts (according to the key currently loaded in the

+ * internal key register) one block of eight bytes at address 'from'

+ * into the block at address 'to'.  They can be the same.

+ */

+

+/* d3des.h V5.09 rwo 9208.04 15:06 Graven Imagery

+ ********************************************************************/

diff -rupN qemu-0.9.0.orig/Makefile.target qemu-0.9.0.new/Makefile.target

--- qemu-0.9.0.orig/Makefile.target	2007-08-27 12:44:06.000000000 -0400

+++ qemu-0.9.0.new/Makefile.target	2007-08-27 13:27:34.000000000 -0400

@@ -356,6 +356,11 @@ SOUND_HW += fmopl.o adlib.o

 endif

 AUDIODRV+= wavcapture.o

+ifdef CONFIG_VNC_TLS

+CPPFLAGS += $(CONFIG_VNC_TLS_CFLAGS)

+LIBS += $(CONFIG_VNC_TLS_LIBS)

+endif

+

 # SCSI layer

 VL_OBJS+= scsi-disk.o cdrom.o lsi53c895a.o

@@ -413,7 +418,7 @@ endif

 ifdef CONFIG_SDL

 VL_OBJS+=sdl.o x_keymap.o

 endif

-VL_OBJS+=vnc.o

+VL_OBJS+=vnc.o d3des.o

 ifdef CONFIG_COCOA

 VL_OBJS+=cocoa.o

 COCOA_LIBS=-F/System/Library/Frameworks -framework Cocoa -framework IOKit

@@ -471,7 +476,7 @@ cocoa.o: cocoa.m

 sdl.o: sdl.c keymaps.c sdl_keysym.h

 	$(CC) $(CFLAGS) $(CPPFLAGS) $(SDL_CFLAGS) $(BASE_CFLAGS) -c -o $@ $<

-vnc.o: vnc.c keymaps.c sdl_keysym.h vnchextile.h

+vnc.o: vnc.c keymaps.c sdl_keysym.h vnchextile.h d3des.c d3des.h

 	$(CC) $(CFLAGS) $(CPPFLAGS) $(BASE_CFLAGS) -c -o $@ $<

 sdlaudio.o: sdlaudio.c

diff -rupN qemu-0.9.0.orig/monitor.c qemu-0.9.0.new/monitor.c

--- qemu-0.9.0.orig/monitor.c	2007-02-05 18:01:54.000000000 -0500

+++ qemu-0.9.0.new/monitor.c	2007-08-27 13:15:46.000000000 -0400

@@ -362,7 +362,7 @@ static void do_eject(int force, const ch

     eject_device(bs, force);

 }

-static void do_change(const char *device, const char *filename)

+static void do_change_block(const char *device, const char *filename)

 {

     BlockDriverState *bs;

     int i;

@@ -387,6 +387,30 @@ static void do_change(const char *device

     }

 }

+static void do_change_vnc(const char *target)

+{

+    if (strcmp(target, "passwd") == 0 ||

+	strcmp(target, "password") == 0) {

+	char password[9];

+	monitor_readline("Password: ", 1, password, sizeof(password)-1);

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

+	if (vnc_display_password(NULL, password) < 0)

+	    term_printf("could not set VNC server password\n");

+    } else {

+	if (vnc_display_open(NULL, target) < 0)

+	    term_printf("could not start VNC server on %s\n", target);

+    }

+}

+

+static void do_change(const char *device, const char *target)

+{

+    if (strcmp(device, "vnc") == 0) {

+	do_change_vnc(target);

+    } else {

+	do_change_block(device, target);

+    }

+}

+

 static void do_screen_dump(const char *filename)

 {

     vga_hw_screen_dump(filename);

diff -rupN qemu-0.9.0.orig/vl.c qemu-0.9.0.new/vl.c

--- qemu-0.9.0.orig/vl.c	2007-02-05 18:01:54.000000000 -0500

+++ qemu-0.9.0.new/vl.c	2007-08-27 13:16:25.000000000 -0400

@@ -173,6 +173,7 @@ const char *option_rom[MAX_OPTION_ROMS];

 int nb_option_roms;

 int semihosting_enabled = 0;

 int autostart = 1;

+const char *qemu_name;

 /***********************************************************/

 /* x86 ISA bus support */

@@ -4140,6 +4141,7 @@ typedef struct IOHandlerRecord {

     IOCanRWHandler *fd_read_poll;

     IOHandler *fd_read;

     IOHandler *fd_write;

+    int deleted;

     void *opaque;

     /* temporary data */

     struct pollfd *ufd;

@@ -4165,8 +4167,7 @@ int qemu_set_fd_handler2(int fd, 

             if (ioh == NULL)

                 break;

             if (ioh->fd == fd) {

-                *pioh = ioh->next;

-                qemu_free(ioh);

+                ioh->deleted = 1;

                 break;

             }

             pioh = &ioh->next;

@@ -4187,6 +4188,7 @@ int qemu_set_fd_handler2(int fd, 

         ioh->fd_read = fd_read;

         ioh->fd_write = fd_write;

         ioh->opaque = opaque;

+        ioh->deleted = 0;

     }

     return 0;

 }

@@ -5835,7 +5837,7 @@ void qemu_system_powerdown_request(void)

 void main_loop_wait(int timeout)

 {

-    IOHandlerRecord *ioh, *ioh_next;

+    IOHandlerRecord *ioh;

     fd_set rfds, wfds, xfds;

     int ret, nfds;

     struct timeval tv;

@@ -5870,6 +5872,8 @@ void main_loop_wait(int timeout)

     FD_ZERO(&wfds);

     FD_ZERO(&xfds);

     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {

+        if (ioh->deleted)

+            continue;

         if (ioh->fd_read &&

             (!ioh->fd_read_poll ||

              ioh->fd_read_poll(ioh->opaque) != 0)) {

@@ -5897,16 +5901,27 @@ void main_loop_wait(int timeout)

 #endif

     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv;;

     if (ret > 0) {

-        /* XXX: better handling of removal */

-        for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {

-            ioh_next = ioh->next;

-            if (FD_ISSET(ioh->fd, &rfds)) {

+        IOHandlerRecord **pioh;

+

+        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {

+            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {

                 ioh->fd_read(ioh->opaque);

             }

-            if (FD_ISSET(ioh->fd, &wfds)) {

+            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {

                 ioh->fd_write(ioh->opaque);

             }

         }

+

+	/* remove deleted IO handlers */

+	pioh = &first_io_handler;

+	while (*pioh) {

+            ioh = *pioh;

+            if (ioh->deleted) {

+                *pioh = ioh->next;

+                qemu_free(ioh);

+            } else 

+                pioh = &ioh->next;

+        }

     }

 #if defined(CONFIG_SLIRP)

     if (slirp_inited) {

@@ -6052,6 +6067,7 @@ void help(void)

 #if defined(TARGET_PPC) || defined(TARGET_SPARC)

            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"

 #endif

+           "-name string    set the name of the guest\n"

            "\n"

            "Network options:\n"

            "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"

@@ -6205,7 +6221,8 @@ enum {

     QEMU_OPTION_no_reboot,

     QEMU_OPTION_daemonize,

     QEMU_OPTION_option_rom,

-    QEMU_OPTION_semihosting

+    QEMU_OPTION_semihosting,

+    QEMU_OPTION_name,

 };

 typedef struct QEMUOption {

@@ -6292,6 +6309,7 @@ const QEMUOption qemu_options[] = {

 #if defined(TARGET_ARM)

     { "semihosting", 0, QEMU_OPTION_semihosting },

 #endif

+    { "name", HAS_ARG, QEMU_OPTION_name },

     { NULL },

 };

@@ -6958,6 +6976,9 @@ int main(int argc, char **argv)

             case QEMU_OPTION_semihosting:

                 semihosting_enabled = 1;

                 break;

+            case QEMU_OPTION_name:

+                qemu_name = optarg;

+                break;

             }

         }

     }

@@ -7154,7 +7175,9 @@ int main(int argc, char **argv)

     if (nographic) {

         dumb_display_init(ds);

     } else if (vnc_display != NULL) {

-	vnc_display_init(ds, vnc_display);

+        vnc_display_init(ds);

+        if (vnc_display_open(ds, vnc_display) < 0)

+            exit(1);

     } else {

 #if defined(CONFIG_SDL)

         sdl_display_init(ds, full_screen);

diff -rupN qemu-0.9.0.orig/vl.h qemu-0.9.0.new/vl.h

--- qemu-0.9.0.orig/vl.h	2007-02-05 18:01:54.000000000 -0500

+++ qemu-0.9.0.new/vl.h	2007-08-27 13:15:46.000000000 -0400

@@ -114,6 +114,7 @@ void hw_error(const char *fmt, ...);

 extern const char *bios_dir;

 extern int vm_running;

+extern const char *qemu_name;

 typedef struct vm_change_state_entry VMChangeStateEntry;

 typedef void VMChangeStateHandler(void *opaque, int running);

@@ -908,7 +909,10 @@ void sdl_display_init(DisplayState *ds, 

 void cocoa_display_init(DisplayState *ds, int full_screen);

 /* vnc.c */

-void vnc_display_init(DisplayState *ds, const char *display);

+void vnc_display_init(DisplayState *ds);

+void vnc_display_close(DisplayState *ds);

+int vnc_display_open(DisplayState *ds, const char *display);

+int vnc_display_password(DisplayState *ds, const char *password);

 void do_info_vnc(void);

 /* x_keymap.c */

diff -rupN qemu-0.9.0.orig/vnc.c qemu-0.9.0.new/vnc.c

--- qemu-0.9.0.orig/vnc.c	2007-02-05 18:01:54.000000000 -0500

+++ qemu-0.9.0.new/vnc.c	2007-08-27 13:15:46.000000000 -0400

@@ -30,6 +30,28 @@

 #include "vnc_keysym.h"

 #include "keymaps.c"

+#include "d3des.h"

+

+#if CONFIG_VNC_TLS

+#include <gnutls/gnutls.h>

+#include <gnutls/x509.h>

+#endif /* CONFIG_VNC_TLS */

+

+// #define _VNC_DEBUG 1

+

+#if _VNC_DEBUG

+#define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)

+

+#if CONFIG_VNC_TLS && _VNC_DEBUG >= 2

+/* Very verbose, so only enabled for _VNC_DEBUG >= 2 */

+static void vnc_debug_gnutls_log(int level, const char* str) {

+    VNC_DEBUG("%d %s", level, str);

+}

+#endif /* CONFIG_VNC_TLS && _VNC_DEBUG */

+#else

+#define VNC_DEBUG(fmt, ...) do { } while (0)

+#endif

+

 typedef struct Buffer

 {

@@ -54,6 +76,45 @@ typedef void VncSendHextileTile(VncState

 #define VNC_MAX_HEIGHT 2048

 #define VNC_DIRTY_WORDS (VNC_MAX_WIDTH / (16 * 32))

+#define VNC_AUTH_CHALLENGE_SIZE 16

+

+enum {

+    VNC_AUTH_INVALID = 0,

+    VNC_AUTH_NONE = 1,

+    VNC_AUTH_VNC = 2,

+    VNC_AUTH_RA2 = 5,

+    VNC_AUTH_RA2NE = 6,

+    VNC_AUTH_TIGHT = 16,

+    VNC_AUTH_ULTRA = 17,

+    VNC_AUTH_TLS = 18,

+    VNC_AUTH_VENCRYPT = 19

+};

+

+#if CONFIG_VNC_TLS

+enum {

+    VNC_WIREMODE_CLEAR,

+    VNC_WIREMODE_TLS,

+};

+

+enum {

+    VNC_AUTH_VENCRYPT_PLAIN = 256,

+    VNC_AUTH_VENCRYPT_TLSNONE = 257,

+    VNC_AUTH_VENCRYPT_TLSVNC = 258,

+    VNC_AUTH_VENCRYPT_TLSPLAIN = 259,

+    VNC_AUTH_VENCRYPT_X509NONE = 260,

+    VNC_AUTH_VENCRYPT_X509VNC = 261,

+    VNC_AUTH_VENCRYPT_X509PLAIN = 262,

+};

+

+#if CONFIG_VNC_TLS

+#define X509_CA_CERT_FILE "ca-cert.pem"

+#define X509_CA_CRL_FILE "ca-crl.pem"

+#define X509_SERVER_KEY_FILE "server-key.pem"

+#define X509_SERVER_CERT_FILE "server-cert.pem"

+#endif

+

+#endif /* CONFIG_VNC_TLS */

+

 struct VncState

 {

     QEMUTimer *timer;

@@ -73,7 +134,27 @@ struct VncState

     int last_x;

     int last_y;

-    const char *display;