Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

24 files changed, 8445 insertions, 0 deletions

diff --git a/krdc/vnc/Makefile.am b/krdc/vnc/Makefile.am
new file mode 100644
index 00000000..23956297
--- /dev/null
+++ b/krdc/vnc/Makefile.am
@@ -0,0 +1,16 @@
+KDE_CXXFLAGS = $(USE_THREADS)
+
+METASOURCES = AUTO
+
+noinst_LTLIBRARIES = libvnc.la
+
+libvnc_la_SOURCES = kvncview.cpp threads.cpp colour.c d3des.c desktop.c \
+  rfbproto.c sockets.c vncauth.c vncprefs.ui vnchostpref.cpp
+
+noinst_HEADERS = kvncview.h rfbproto.h  vncviewer.h vnctypes.h vncauth.h \
+   pointerlatencyometer.h threads.h d3des.h vnchostpref.h
+
+libvnc_la_LIBADD   = $(LIB_KDEUI) $(LIBJPEG)
+libvnc_la_LDFLAGS = $(all_libraries) $(KDE_RPATH)
+
+INCLUDES= -I$(top_srcdir)/krdc -I.. $(all_includes)
diff --git a/krdc/vnc/colour.c b/krdc/vnc/colour.c
new file mode 100644
index 00000000..a51d6e61
--- /dev/null
+++ b/krdc/vnc/colour.c
@@ -0,0 +1,415 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * colour.c - functions to deal with colour - i.e. RFB pixel formats, X visuals
+ * and colormaps.  Thanks to Grant McDorman for some of the ideas used here.
+ */
+
+#include "vncviewer.h"
+#include <limits.h>
+
+
+#define INVALID_PIXEL 0xffffffff
+#define MAX_CMAP_SIZE 256
+#define BGR233_SIZE 256
+unsigned long BGR233ToPixel[BGR233_SIZE];
+
+Colormap cmap;
+Visual *vis;
+unsigned int visdepth, visbpp;
+Bool allocColorFailed = False;
+
+static int nBGR233ColoursAllocated;
+
+static int GetBPPForDepth(int depth);
+static void SetupBGR233Map(void);
+static void AllocateExactBGR233Colours(void);
+static Bool AllocateBGR233Colour(int r, int g, int b);
+
+
+/*
+ * SetVisualAndCmap() deals with the wonderful world of X "visuals" (which are
+ * equivalent to the RFB protocol's "pixel format").  Having decided on the
+ * best visual, it also creates a colormap if necessary, sets the appropriate
+ * resources on the toplevel widget, and sets up the myFormat structure to
+ * describe the pixel format in terms that the RFB server will be able to
+ * understand.
+ *
+ * The algorithm for deciding which visual to use is as follows:
+ *
+ * If forceOwnCmap is true then we try to use a PseudoColor visual - we first
+ * see if there's one of the same depth as the RFB server, followed by an 8-bit
+ * deep one.
+ *
+ * If forceTrueColour is true then we try to use a TrueColor visual - if
+ * requestedDepth is set then it must be of that depth, otherwise any depth
+ * will be used.
+ *
+ * Otherwise, we use the X server's default visual and colormap.  If this is
+ * TrueColor then we just ask the RFB server for this format.  If the default
+ * isn't TrueColor, or if useBGR233 is true, then we ask the RFB server for
+ * BGR233 pixel format and use a lookup table to translate to the nearest
+ * colours provided by the X server.
+ */
+
+void
+SetVisualAndCmap()
+{
+  /* just use default visual and colormap */
+
+  vis = DefaultVisual(dpy,DefaultScreen(dpy));
+  visdepth = DefaultDepth(dpy,DefaultScreen(dpy));
+  visbpp = GetBPPForDepth(visdepth);
+  cmap = DefaultColormap(dpy,DefaultScreen(dpy));
+
+  if (!appData.useBGR233 && (vis->class == TrueColor)) {
+
+    myFormat.bitsPerPixel = visbpp;
+    myFormat.depth = visdepth;
+    myFormat.trueColour = 1;
+    myFormat.bigEndian = (ImageByteOrder(dpy) == MSBFirst);
+    myFormat.redShift = ffs(vis->red_mask) - 1;
+    myFormat.greenShift = ffs(vis->green_mask) - 1;
+    myFormat.blueShift = ffs(vis->blue_mask) - 1;
+    myFormat.redMax = vis->red_mask >> myFormat.redShift;
+    myFormat.greenMax = vis->green_mask >> myFormat.greenShift;
+    myFormat.blueMax = vis->blue_mask >> myFormat.blueShift;
+
+    fprintf(stderr,
+	    "Using default colormap which is TrueColor.  Pixel format:\n");
+    PrintPixelFormat(&myFormat);
+    return;
+  }
+
+  appData.useBGR233 = True;
+
+  myFormat.bitsPerPixel = 8;
+  myFormat.depth = 8;
+  myFormat.trueColour = 1;
+  myFormat.bigEndian = 0;
+  myFormat.redMax = 7;
+  myFormat.greenMax = 7;
+  myFormat.blueMax = 3;
+  myFormat.redShift = 0;
+  myFormat.greenShift = 3;
+  myFormat.blueShift = 6;
+
+  fprintf(stderr,
+       "Using default colormap and translating from BGR233.  Pixel format:\n");
+  PrintPixelFormat(&myFormat);
+
+  SetupBGR233Map();
+}
+
+
+/*
+ * GetBPPForDepth looks through the "pixmap formats" to find the bits-per-pixel
+ * for the given depth.
+ */
+
+static int
+GetBPPForDepth(int depth)
+{
+  XPixmapFormatValues *format;
+  int nformats;
+  int i;
+  int bpp;
+
+  format = XListPixmapFormats(dpy, &nformats);
+
+  for (i = 0; i < nformats; i++) {
+    if (format[i].depth == depth)
+      break;
+  }
+
+  if (i == nformats) {
+    fprintf(stderr,"no pixmap format for depth %d???\n", depth);
+    exit(1);
+  }
+
+  bpp = format[i].bits_per_pixel;
+
+  XFree(format);
+
+  if (bpp != 1 && bpp != 8 && bpp != 16 && bpp != 32) {
+    fprintf(stderr,"Can't cope with %d bits-per-pixel.  Sorry.\n", bpp);
+    exit(1);
+  }
+
+  return bpp;
+}
+
+
+
+/*
+ * SetupBGR233Map() sets up the BGR233ToPixel array.
+ *
+ * It calls AllocateExactBGR233Colours to allocate some exact BGR233 colours
+ * (limited by space in the colormap and/or by the value of the nColours
+ * resource).  If the number allocated is less than BGR233_SIZE then it fills
+ * the rest in using the "nearest" colours available.  How this is done depends
+ * on the value of the useSharedColours resource.  If it's false, we use only
+ * colours from the exact BGR233 colours we've just allocated.  If it's true,
+ * then we also use other clients' "shared" colours available in the colormap.
+ */
+
+static void
+SetupBGR233Map(void)
+{
+  int r, g, b;
+  long i;
+  unsigned long nearestPixel = 0;
+  int cmapSize;
+  XColor cmapEntry[MAX_CMAP_SIZE];
+  Bool exactBGR233[MAX_CMAP_SIZE];
+  Bool shared[MAX_CMAP_SIZE];
+  Bool usedAsNearest[MAX_CMAP_SIZE];
+  int nSharedUsed = 0;
+
+  if (visdepth > 8) {
+    appData.nColours = 256; /* ignore nColours setting for > 8-bit deep */
+  }
+
+  for (i = 0; i < BGR233_SIZE; i++) {
+    BGR233ToPixel[i] = INVALID_PIXEL;
+  }
+
+  AllocateExactBGR233Colours();
+
+  fprintf(stderr,"Got %d exact BGR233 colours out of %d\n",
+	  nBGR233ColoursAllocated, appData.nColours);
+
+  if (nBGR233ColoursAllocated < BGR233_SIZE) {
+
+    if (visdepth > 8) { /* shouldn't get here */
+      fprintf(stderr,"Error: couldn't allocate BGR233 colours even though "
+	      "depth is %d\n", visdepth);
+      exit(1);
+    }
+
+    cmapSize = (1 << visdepth);
+
+    for (i = 0; i < cmapSize; i++) {
+      cmapEntry[i].pixel = i;
+      exactBGR233[i] = False;
+      shared[i] = False;
+      usedAsNearest[i] = False;
+    }
+
+    XQueryColors(dpy, cmap, cmapEntry, cmapSize);
+
+    /* mark all our exact BGR233 pixels */
+
+    for (i = 0; i < BGR233_SIZE; i++) {
+      if (BGR233ToPixel[i] != INVALID_PIXEL)
+	exactBGR233[BGR233ToPixel[i]] = True;
+    }
+
+    if (appData.useSharedColours) {
+
+      /* Try to find existing shared colours.  This is harder than it sounds
+	 because XQueryColors doesn't tell us whether colours are shared,
+	 private or unallocated.  What we do is go through the colormap and for
+	 each pixel try to allocate exactly its RGB values.  If this returns a
+	 different pixel then it's definitely either a private or unallocated
+	 pixel, so no use to us.  If it returns us the same pixel again, then
+	 it's likely that it's a shared colour - however, it is possible that
+	 it was actually an unallocated pixel, which we've now allocated.  We
+	 minimise this possibility by going through the pixels in reverse order
+	 - this helps becuse the X server allocates new pixels from the lowest
+	 number up, so it should only be a problem for the lowest unallocated
+	 pixel.  Got that? */
+
+      for (i = cmapSize-1; i >= 0; i--) {
+	if (!exactBGR233[i] &&
+	    XAllocColor(dpy, cmap, &cmapEntry[i])) {
+
+	  if (cmapEntry[i].pixel == (unsigned long) i) {
+
+	    shared[i] = True; /* probably shared */
+
+	  } else {
+
+	    /* "i" is either unallocated or private.  We have now unnecessarily
+	       allocated cmapEntry[i].pixel.  Free it. */
+
+	    XFreeColors(dpy, cmap, &cmapEntry[i].pixel, 1, 0);
+	  }
+	}
+      }
+    }
+
+    /* Now fill in the nearest colours */
+
+    for (r = 0; r < 8; r++) {
+      for (g = 0; g < 8; g++) {
+	for (b = 0; b < 4; b++) {
+	  if (BGR233ToPixel[(b<<6) | (g<<3) | r] == INVALID_PIXEL) {
+
+	    unsigned long minDistance = ULONG_MAX;
+
+	    for (i = 0; i < cmapSize; i++) {
+	      if (exactBGR233[i] || shared[i]) {
+		unsigned long distance
+		  = (abs(cmapEntry[i].red - r * 65535 / 7)
+		     + abs(cmapEntry[i].green - g * 65535 / 7)
+		     + abs(cmapEntry[i].blue - b * 65535 / 3));
+
+		if (distance < minDistance) {
+		  minDistance = distance;
+		  nearestPixel = i;
+		}
+	      }
+	    }
+
+	    BGR233ToPixel[(b<<6) | (g<<3) | r] = nearestPixel;
+	    if (shared[nearestPixel] && !usedAsNearest[nearestPixel])
+	      nSharedUsed++;
+	    usedAsNearest[nearestPixel] = True;
+	  }
+	}
+      }
+    }
+
+    /* Tidy up shared colours which we allocated but aren't going to use */
+
+    for (i = 0; i < cmapSize; i++) {
+      if (shared[i] && !usedAsNearest[i]) {
+	  XFreeColors(dpy, cmap, (unsigned long *)&i, 1, 0);
+      }
+    }
+
+    fprintf(stderr,"Using %d existing shared colours\n", nSharedUsed);
+  }
+}
+
+
+/*
+ * AllocateExactBGR233Colours() attempts to allocate each of the colours in the
+ * BGR233 colour cube, stopping when an allocation fails.  The order it does
+ * this in is such that we should get a fairly well spread subset of the cube,
+ * however many allocations are made.  There's probably a neater algorithm for
+ * doing this, but it's not obvious to me anyway.  The way this algorithm works
+ * is:
+ *
+ * At each stage, we introduce a new value for one of the primaries, and
+ * allocate all the colours with the new value of that primary and all previous
+ * values of the other two primaries.  We start with r=0 as the "new" value
+ * for r, and g=0, b=0 as the "previous" values of g and b.  So we get:
+ *
+ * New primary value   Previous values of other primaries   Colours allocated
+ * -----------------   ----------------------------------   -----------------
+ * r=0                 g=0       b=0                        r0 g0 b0
+ * g=7                 r=0       b=0                        r0 g7 b0
+ * b=3                 r=0       g=0,7                      r0 g0 b3
+ *                                                          r0 g7 b3
+ * r=7                 g=0,7     b=0,3                      r7 g0 b0
+ * 		       		 			    r7 g0 b3
+ * 							    r7 g7 b0
+ *							    r7 g7 b3
+ * g=3                 r=0,7     b=0,3                      r0 g3 b0
+ *                                                          r0 g3 b3
+ *                                                          r7 g3 b0
+ *                                                          r7 g3 b3
+ * ....etc.
+ * */
+
+static void
+AllocateExactBGR233Colours(void)
+{
+  int rv[] = {0,7,3,5,1,6,2,4};
+  int gv[] = {0,7,3,5,1,6,2,4};
+  int bv[] = {0,3,1,2};
+  int rn = 0;
+  int gn = 1;
+  int bn = 1;
+  int ri, gi, bi;
+
+  nBGR233ColoursAllocated = 0;
+
+  while (1) {
+    if (rn == 8)
+      break;
+
+    ri = rn;
+    for (gi = 0; gi < gn; gi++) {
+      for (bi = 0; bi < bn; bi++) {
+	if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
+	  return;
+      }
+    }
+    rn++;
+
+    if (gn == 8)
+      break;
+
+    gi = gn;
+    for (ri = 0; ri < rn; ri++) {
+      for (bi = 0; bi < bn; bi++) {
+	if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
+	  return;
+      }
+    }
+    gn++;
+
+    if (bn < 4) {
+
+      bi = bn;
+      for (ri = 0; ri < rn; ri++) {
+	for (gi = 0; gi < gn; gi++) {
+	  if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
+	    return;
+	}
+      }
+      bn++;
+    }
+  }
+}
+
+
+/*
+ * AllocateBGR233Colour() attempts to allocate the given BGR233 colour as a
+ * shared colormap entry, storing its pixel value in the BGR233ToPixel array.
+ * r is from 0 to 7, g from 0 to 7 and b from 0 to 3.  It fails either when the
+ * allocation fails or when we would exceed the number of colours specified in
+ * the nColours resource.
+ */
+
+static Bool
+AllocateBGR233Colour(int r, int g, int b)
+{
+  XColor c;
+
+  if (nBGR233ColoursAllocated >= appData.nColours)
+    return False;
+
+  c.red = r * 65535 / 7;
+  c.green = g * 65535 / 7;
+  c.blue = b * 65535 / 3;
+
+  if (!XAllocColor(dpy, cmap, &c))
+    return False;
+
+  BGR233ToPixel[(b<<6) | (g<<3) | r] = c.pixel;
+
+  nBGR233ColoursAllocated++;
+
+  return True;
+}
diff --git a/krdc/vnc/d3des.c b/krdc/vnc/d3des.c
new file mode 100644
index 00000000..8a358ce6
--- /dev/null
+++ b/krdc/vnc/d3des.c
@@ -0,0 +1,440 @@
+/*
+ * 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 long KnR[32] = { 0L };
+static unsigned long Kn3[32] = { 0L };
+static unsigned char Df_Key[24] = {
+	0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
+	0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
+	0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67 };
+
+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++ = (*outof >> 24) & 0xffL;
+	*into++ = (*outof >> 16) & 0xffL;
+	*into++ = (*outof >>  8) & 0xffL;
+	*into++ =  *outof++	 & 0xffL;
+	*into++ = (*outof >> 24) & 0xffL;
+	*into++ = (*outof >> 16) & 0xffL;
+	*into++ = (*outof >>  8) & 0xffL;
+	*into	=  *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 --git a/krdc/vnc/d3des.h b/krdc/vnc/d3des.h
new file mode 100644
index 00000000..ea3da44c
--- /dev/null
+++ b/krdc/vnc/d3des.h
@@ -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 --git a/krdc/vnc/desktop.c b/krdc/vnc/desktop.c
new file mode 100644
index 00000000..f5a60966
--- /dev/null
+++ b/krdc/vnc/desktop.c
@@ -0,0 +1,1613 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *  Copyright (C) 2002 Tim Jansen. All Rights Reserved.
+ *  Copyright (C) 1999-2001 Anders Lindström
+ * 
+ *  
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ *
+ * tim@tjansen.de: - removed stuff for krdc 
+ *                 - merged with shm.c and misc.c
+ *                 - added FillRectangle and Sync methods to draw only on 
+ *                   the image
+ *                 - added Zoom functionality, based on rotation funcs from
+ *                   SGE by Anders Lindström)
+ *                 - added support for softcursor encoding
+ *
+ */
+
+/*
+ * desktop.c - functions to deal with "desktop" window.
+ */
+
+#include <X11/Xlib.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/extensions/XShm.h>
+#include <math.h>
+#include <limits.h>
+#include "vncviewer.h"
+
+static XShmSegmentInfo shminfo;
+static Bool caughtShmError = False;
+static Bool needShmCleanup = False;
+
+static XShmSegmentInfo zoomshminfo;
+static Bool caughtZoomShmError = False;
+static Bool needZoomShmCleanup = False;
+
+static Bool gcInited = False;
+GC gc;
+GC srcGC, dstGC; /* used for debugging copyrect */
+Dimension dpyWidth, dpyHeight;
+
+static XImage *image = NULL;
+Bool useShm = True;
+
+static Bool zoomActive = False;
+static int zoomWidth, zoomHeight;
+static XImage *zoomImage = NULL;
+static Bool useZoomShm = True;
+
+/* for softcursor */
+static char *savedArea = NULL;
+
+typedef enum {
+  SOFTCURSOR_UNDER,
+  SOFTCURSOR_PART_UNDER,
+  SOFTCURSOR_UNAFFECTED
+} SoftCursorState;
+
+typedef int Sint32;
+typedef short Sint16;
+typedef char Sint8;
+typedef unsigned int Uint32;
+typedef unsigned short Uint16;
+typedef unsigned char Uint8;
+
+typedef struct {
+  int w, h;
+  unsigned int pitch;
+  void *pixels;
+  int BytesPerPixel;
+} Surface;
+
+typedef struct {
+        Sint16 x, y;
+        Uint16 w, h;
+} Rect;
+
+static void bgr233cpy(CARD8 *dst, CARD8 *src, int len);
+static void CopyDataToScreenRaw(char *buf, int x, int y, int width, int height);
+static void CopyBGR233ToScreen(CARD8 *buf, int x, int y, int width,int height);
+static void FillRectangleBGR233(CARD8 buf, int x, int y, int width,int height);
+static int CheckRectangle(int x, int y, int width, int height);
+static SoftCursorState getSoftCursorState(int x, int y, int width, int height);
+static void discardCursorSavedArea(void);
+static void saveCursorSavedArea(void);
+
+static void ZoomInit(void);
+static void transformZoomSrc(int six, int siy, int siw, int sih,
+			     int *dix, int *diy, int *diw, int *dih,
+			     int srcW, int dstW, int srcH, int dstH);
+static void transformZoomDst(int *six, int *siy, int *siw, int *sih,
+			     int dix, int diy, int diw, int dih,
+			     int srcW, int dstW, int srcH, int dstH);
+static void ZoomSurfaceSrcCoords(int x, int y, int w, int h, 
+				 int *dix, int *diy, int *diw, int *dih,
+				 Surface * src, Surface * dst);
+static void ZoomSurfaceCoords32(int sx, int sy, int sw, int sh,
+				int dx, int dy, Surface * src, Surface * dst);
+static void sge_transform(Surface *src, Surface *dst, float xscale, float yscale,
+			  Uint16 qx, Uint16 qy);
+
+
+void
+DesktopInit(Window win)
+{
+  XGCValues gcv;
+
+  image = CreateShmImage();
+
+  if (!image) {
+    useShm = False;
+    image = XCreateImage(dpy, vis, visdepth, ZPixmap, 0, NULL,
+			 si.framebufferWidth, si.framebufferHeight,
+			 BitmapPad(dpy), 0);
+
+    image->data = calloc(image->bytes_per_line * image->height, 1);
+    if (!image->data) {
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+  }
+
+  gc = XCreateGC(dpy,win,0,NULL);
+
+  gcv.function = GXxor;
+  gcv.foreground = 0x0f0f0f0f;
+  srcGC = XCreateGC(dpy,win,GCFunction|GCForeground,&gcv);
+  gcv.foreground = 0xf0f0f0f0;
+  dstGC = XCreateGC(dpy,win,GCFunction|GCForeground,&gcv);
+  gcInited = True;
+}
+
+/*
+ * DrawScreenRegionX11Thread
+ * Never call from any other desktop.c function, only for X11 thread
+ */
+
+void
+DrawScreenRegionX11Thread(Window win, int x, int y, int width, int height) {
+  zoomActive = False;
+  zoomWidth = 0;
+  zoomHeight = 0;
+
+  if (!image)
+    return;
+
+  if (useShm) 
+    XShmPutImage(dpy, win, gc, image, x, y, x, y, width, height, False);
+  else
+    XPutImage(dpy, win, gc, image, x, y, x, y, width, height);
+}
+
+/*
+ * CheckRectangle
+ */
+
+static int CheckRectangle(int x, int y, int width, int height) {
+  if ((x < 0) || (y < 0))
+    return 0;
+
+  if (((x+width) > si.framebufferWidth) || ((y+height) > si.framebufferHeight))
+    return 0;
+
+  return 1;
+}
+
+static 
+void bgr233cpy(CARD8 *dst, CARD8 *src, int len) {
+  int i;
+  CARD16 *d16;
+  CARD32 *d32;
+
+  switch (visbpp) {
+  case 8:
+    for (i = 0; i < len; i++) 
+      *(dst++) = (CARD8) BGR233ToPixel[*(src++)];
+    break;
+  case 16:
+    d16 = (CARD16*) dst;
+    for (i = 0; i < len; i++) 
+      *(d16++) = (CARD16) BGR233ToPixel[*(src++)];
+    break;
+  case 32:
+    d32 = (CARD32*) dst;
+    for (i = 0; i < len; i++) 
+      *(d32++) = (CARD32) BGR233ToPixel[*(src++)];
+    break;
+  default:
+    fprintf(stderr, "Unsupported softcursor depth %d\n", visbpp);
+  }
+}
+
+
+/*
+ * CopyDataToScreen.
+ */
+
+void
+CopyDataToScreen(char *buf, int x, int y, int width, int height)
+{
+  SoftCursorState s;
+
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  LockFramebuffer();
+  s = getSoftCursorState(x, y, width, height);
+  if (s == SOFTCURSOR_PART_UNDER)
+    undrawCursor();
+
+  if (!appData.useBGR233)
+    CopyDataToScreenRaw(buf, x, y, width, height);
+  else
+    CopyBGR233ToScreen((CARD8 *)buf, x, y, width, height);
+
+  if (s != SOFTCURSOR_UNAFFECTED)
+    drawCursor();
+
+  UnlockFramebuffer();
+  SyncScreenRegion(x, y, width, height);
+}
+
+/*
+ * CopyDataToScreenRaw.
+ */
+
+static void
+CopyDataToScreenRaw(char *buf, int x, int y, int width, int height)
+{
+  int h;
+  int widthInBytes = width * visbpp / 8;
+  int scrWidthInBytes = image->bytes_per_line;
+  char *scr = (image->data + y * scrWidthInBytes
+	       + x * visbpp / 8);
+  
+  for (h = 0; h < height; h++) {
+    memcpy(scr, buf, widthInBytes);
+    buf += widthInBytes;
+    scr += scrWidthInBytes;
+  }
+}
+
+/*
+ * CopyBGR233ToScreen.
+ */
+
+static void
+CopyBGR233ToScreen(CARD8 *buf, int x, int y, int width, int height)
+{
+  int p, q;
+  int xoff = 7 - (x & 7);
+  int xcur;
+  int fbwb = si.framebufferWidth / 8;
+  CARD8 *scr1 = ((CARD8 *)image->data) + y * fbwb + x / 8;
+  CARD8 *scrt;
+  CARD8 *scr8 = ((CARD8 *)image->data) + y * si.framebufferWidth + x;
+  CARD16 *scr16 = ((CARD16 *)image->data) + y * si.framebufferWidth + x;
+  CARD32 *scr32 = ((CARD32 *)image->data) + y * si.framebufferWidth + x;
+
+  switch (visbpp) {
+
+    /* thanks to Chris Hooper for single bpp support */
+
+  case 1:
+    for (q = 0; q < height; q++) {
+      xcur = xoff;
+      scrt = scr1;
+      for (p = 0; p < width; p++) {
+	*scrt = ((*scrt & ~(1 << xcur))
+		 | (BGR233ToPixel[*(buf++)] << xcur));
+
+	if (xcur-- == 0) {
+	  xcur = 7;
+	  scrt++;
+	}
+      }
+      scr1 += fbwb;
+    }
+    break;
+
+  case 8:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr8++) = BGR233ToPixel[*(buf++)];
+      }
+      scr8 += si.framebufferWidth - width;
+    }
+    break;
+
+  case 16:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr16++) = BGR233ToPixel[*(buf++)];
+      }
+      scr16 += si.framebufferWidth - width;
+    }
+    break;
+
+  case 32:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr32++) = BGR233ToPixel[*(buf++)];
+      }
+      scr32 += si.framebufferWidth - width;
+    }
+    break;
+  }
+}
+
+/*
+ * FillRectangle8.
+ */
+
+void
+FillRectangle8(CARD8 fg, int x, int y, int width, int height)
+{
+  SoftCursorState s;
+
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  s = getSoftCursorState(x, y, width, height);
+  if (s == SOFTCURSOR_PART_UNDER)
+    undrawCursor();
+
+  if (!appData.useBGR233) {
+    int h;
+    int widthInBytes = width * visbpp / 8;
+    int scrWidthInBytes = image->bytes_per_line;
+
+    char *scr = (image->data + y * scrWidthInBytes
+		 + x * visbpp / 8);
+
+    for (h = 0; h < height; h++) {
+      memset(scr, fg, widthInBytes);
+      scr += scrWidthInBytes;
+    }
+  } else {
+    FillRectangleBGR233(fg, x, y, width, height);
+  }
+
+  if (s != SOFTCURSOR_UNAFFECTED)
+    drawCursor();
+}
+
+/*
+ * FillRectangleBGR233.
+ */
+
+static void
+FillRectangleBGR233(CARD8 fg, int x, int y, int width, int height)
+{
+  int p, q;
+  int xoff = 7 - (x & 7);
+  int xcur;
+  int fbwb = si.framebufferWidth / 8;
+  CARD8 *scr1 = ((CARD8 *)image->data) + y * fbwb + x / 8;
+  CARD8 *scrt;
+  CARD8 *scr8 = ((CARD8 *)image->data) + y * si.framebufferWidth + x;
+  CARD16 *scr16 = ((CARD16 *)image->data) + y * si.framebufferWidth + x;
+  CARD32 *scr32 = ((CARD32 *)image->data) + y * si.framebufferWidth + x;
+
+  unsigned long fg233 = BGR233ToPixel[fg];
+
+  switch (visbpp) {
+
+    /* thanks to Chris Hooper for single bpp support */
+
+  case 1:
+    for (q = 0; q < height; q++) {
+      xcur = xoff;
+      scrt = scr1;
+      for (p = 0; p < width; p++) {
+	*scrt = ((*scrt & ~(1 << xcur))
+		 | (fg233 << xcur));
+
+	if (xcur-- == 0) {
+	  xcur = 7;
+	  scrt++;
+	}
+      }
+      scr1 += fbwb;
+    }
+    break;
+
+  case 8:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr8++) = fg233;
+      }
+      scr8 += si.framebufferWidth - width;
+    }
+    break;
+
+  case 16:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr16++) = fg233;
+      }
+      scr16 += si.framebufferWidth - width;
+    }
+    break;
+
+  case 32:
+    for (q = 0; q < height; q++) {
+      for (p = 0; p < width; p++) {
+	*(scr32++) = fg233;
+      }
+      scr32 += si.framebufferWidth - width;
+    }
+    break;
+  }
+}
+
+/*
+ * FillRectangle16
+ */
+
+void
+FillRectangle16(CARD16 fg, int x, int y, int width, int height)
+{
+  int i, h;
+  int scrWidthInBytes = image->bytes_per_line;
+  
+  char *scr = (image->data + y * scrWidthInBytes
+	       + x * visbpp / 8);
+  CARD16 *scr16;
+  SoftCursorState s;
+
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  s = getSoftCursorState(x, y, width, height);
+  if (s == SOFTCURSOR_PART_UNDER)
+    undrawCursor();
+
+  for (h = 0; h < height; h++) {
+    scr16 = (CARD16*) scr;
+    for (i = 0; i < width; i++)
+      scr16[i] = fg;
+    scr += scrWidthInBytes;
+  }
+
+  if (s != SOFTCURSOR_UNAFFECTED)
+    drawCursor();
+}
+
+/*
+ * FillRectangle32
+ */
+
+void
+FillRectangle32(CARD32 fg, int x, int y, int width, int height)
+{
+  int i, h;
+  int scrWidthInBytes = image->bytes_per_line;
+  SoftCursorState s;
+  
+  char *scr = (image->data + y * scrWidthInBytes
+	       + x * visbpp / 8);
+  CARD32 *scr32;
+
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  s = getSoftCursorState(x, y, width, height);
+  if (s == SOFTCURSOR_PART_UNDER)
+    undrawCursor();
+
+  for (h = 0; h < height; h++) {
+    scr32 = (CARD32*) scr;
+    for (i = 0; i < width; i++)
+      scr32[i] = fg;
+    scr += scrWidthInBytes;
+  }
+
+  if (s != SOFTCURSOR_UNAFFECTED)
+    drawCursor();
+}
+
+/*
+ * CopyDataFromScreen.
+ */
+
+void
+CopyDataFromScreen(char *buf, int x, int y, int width, int height)
+{
+  int widthInBytes = width * visbpp / 8;
+  int scrWidthInBytes = image->bytes_per_line;
+  char *src = (image->data + y * scrWidthInBytes
+	       + x * visbpp / 8);
+  int h;
+
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  for (h = 0; h < height; h++) {
+    memcpy(buf, src, widthInBytes);
+    src += scrWidthInBytes;
+    buf += widthInBytes;
+  }
+}
+
+/*
+ * CopyArea
+ */
+
+void
+CopyArea(int srcX, int srcY, int width, int height, int x, int y)
+{
+  int widthInBytes = width * visbpp / 8;
+  SoftCursorState sSrc, sDst;
+
+  LockFramebuffer();
+  sSrc = getSoftCursorState(srcX, srcY, width, height);
+  sDst = getSoftCursorState(x, y, width, height);
+  if ((sSrc != SOFTCURSOR_UNAFFECTED) ||
+      (sDst == SOFTCURSOR_PART_UNDER))
+    undrawCursor();
+
+  if ((srcY+height < y) || (y+height < srcY) ||
+      (srcX+width  < x) || (x+width  < srcX)) {
+
+    int scrWidthInBytes = image->bytes_per_line;
+    char *src = (image->data + srcY * scrWidthInBytes
+		 + srcX * visbpp / 8);
+    char *dst = (image->data + y * scrWidthInBytes
+		 + x * visbpp / 8);
+    int h;
+
+    if (!CheckRectangle(srcX, srcY, width, height)) {
+      UnlockFramebuffer();
+      return;
+    }
+    if (!CheckRectangle(x, y, width, height)) {
+      UnlockFramebuffer();
+      return;
+    }
+      
+    for (h = 0; h < height; h++) {
+      memcpy(dst, src, widthInBytes);
+      src += scrWidthInBytes;
+      dst += scrWidthInBytes;
+    }
+  }
+  else { 
+    char *buf = malloc(widthInBytes*height);
+    if (!buf) {
+      UnlockFramebuffer();
+      fprintf(stderr, "Out of memory, CopyArea impossible\n");
+      return;
+    }
+    CopyDataFromScreen(buf, srcX, srcY, width, height);
+    CopyDataToScreenRaw(buf, x, y, width, height);
+    free(buf);
+  }
+  if ((sSrc != SOFTCURSOR_UNAFFECTED) ||
+      (sDst != SOFTCURSOR_UNAFFECTED))
+    drawCursor();
+  UnlockFramebuffer();
+  SyncScreenRegion(x, y, width, height);
+}
+
+void SyncScreenRegion(int x, int y, int width, int height) {
+  int dx, dy, dw, dh; 
+
+  if (zoomActive) {
+    Surface src, dest;
+    src.w = si.framebufferWidth;
+    src.h = si.framebufferHeight;
+    src.pitch = image->bytes_per_line;
+    src.pixels = image->data;
+    src.BytesPerPixel = visbpp / 8;
+    dest.w = zoomWidth;
+    dest.h = zoomHeight;
+    dest.pitch = zoomImage->bytes_per_line;
+    dest.pixels = zoomImage->data;
+    dest.BytesPerPixel = visbpp / 8;
+    ZoomSurfaceSrcCoords(x, y, width, height, &dx, &dy, &dw, &dh, &src, &dest);
+  }
+  else {
+    dx = x; dy = y;
+    dw = width; dh = height;
+  }
+  DrawScreenRegion(dx, dy, dw, dh);
+}
+
+void SyncScreenRegionX11Thread(int x, int y, int width, int height) {
+  int dx, dy, dw, dh; 
+
+  if (zoomActive) {
+    Surface src, dest;
+    src.w = si.framebufferWidth;
+    src.h = si.framebufferHeight;
+    src.pitch = image->bytes_per_line;
+    src.pixels = image->data;
+    src.BytesPerPixel = visbpp / 8;
+    dest.w = zoomWidth;
+    dest.h = zoomHeight;
+    dest.pitch = zoomImage->bytes_per_line;
+    dest.pixels = zoomImage->data;
+    dest.BytesPerPixel = visbpp / 8;
+    ZoomSurfaceSrcCoords(x, y, width, height, &dx, &dy, &dw, &dh, &src, &dest);
+  }
+  else {
+    dx = x; dy = y;
+    dw = width; dh = height;
+  }
+  DrawAnyScreenRegionX11Thread(dx, dy, dw, dh);
+}
+
+/*
+ * ToplevelInitBeforeRealization sets the title, geometry and other resources
+ * on the toplevel window.
+ */
+
+void
+ToplevelInit()
+{
+  dpyWidth = WidthOfScreen(DefaultScreenOfDisplay(dpy));
+  dpyHeight = HeightOfScreen(DefaultScreenOfDisplay(dpy));
+}
+
+/*
+ * Cleanup - perform shm cleanup operations prior to exiting.
+ */
+
+void
+Cleanup()
+{
+  if (useShm || useZoomShm)
+    ShmCleanup();
+}
+
+void
+ShmCleanup()
+{
+  fprintf(stderr,"ShmCleanup called\n");
+  if (needShmCleanup) {
+    shmdt(shminfo.shmaddr);
+    shmctl(shminfo.shmid, IPC_RMID, 0);
+    needShmCleanup = False;
+  }
+  if (needZoomShmCleanup) {
+    shmdt(zoomshminfo.shmaddr);
+    shmctl(zoomshminfo.shmid, IPC_RMID, 0);
+    needZoomShmCleanup = False;
+  }
+}
+
+static int
+ShmCreationXErrorHandler(Display *d, XErrorEvent *e)
+{
+  caughtShmError = True;
+  return 0;
+}
+
+XImage *
+CreateShmImage()
+{
+  XImage *_image;
+  XErrorHandler oldXErrorHandler;
+
+  if (!XShmQueryExtension(dpy))
+    return NULL;
+
+  _image = XShmCreateImage(dpy, vis, visdepth, ZPixmap, NULL, &shminfo,
+			  si.framebufferWidth, si.framebufferHeight);
+  if (!_image) return NULL;
+
+  shminfo.shmid = shmget(IPC_PRIVATE,
+			 _image->bytes_per_line * _image->height,
+			 IPC_CREAT|0777);
+
+  if (shminfo.shmid == -1) {
+    XDestroyImage(_image);
+    return NULL;
+  }
+
+  shminfo.shmaddr = _image->data = shmat(shminfo.shmid, 0, 0);
+
+  if (shminfo.shmaddr == (char *)-1) {
+    XDestroyImage(_image);
+    shmctl(shminfo.shmid, IPC_RMID, 0);
+    return NULL;
+  }
+
+  shminfo.readOnly = True;
+
+  oldXErrorHandler = XSetErrorHandler(ShmCreationXErrorHandler);
+  XShmAttach(dpy, &shminfo);
+  XSync(dpy, False);
+  XSetErrorHandler(oldXErrorHandler);
+
+  if (caughtShmError) {
+    XDestroyImage(_image);
+    shmdt(shminfo.shmaddr);
+    shmctl(shminfo.shmid, IPC_RMID, 0);
+    return NULL;
+  }
+
+  needShmCleanup = True;
+
+  fprintf(stderr,"Using shared memory PutImage\n");
+
+  return _image;
+}
+
+void undrawCursor() {
+  int x, y, w, h;
+  
+  if ((imageIndex < 0) || !savedArea)
+    return;
+
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&x, &y, &w, &h);
+
+  if ((w < 1) || (h < 1))
+    return;
+
+  CopyDataToScreenRaw(savedArea, x, y, w, h);
+  discardCursorSavedArea();
+}
+
+static void drawCursorImage() {
+  int x, y, w, h, pw, pixelsLeft, processingMask;
+  int skipLeft, skipRight;
+  PointerImage *pi = &pointerImages[imageIndex];
+  CARD8 *img = (CARD8*) pi->image;
+  CARD8 *imgEnd = &img[pi->len];
+  CARD8 *fb;
+
+  /* check whether the source image has ended (image broken) */
+#define CHECK_IMG(x) if (&img[x] > imgEnd) goto imgError
+
+/* check whether the end of the framebuffer has been reached (last line) */
+#define CHECK_END()  if ((wl == 0) && (h == 1)) return
+
+/* skip x pixels in the source (x must be < pixelsLeft!) */
+#define SKIP_IMG(x)  if ((x > 0) && !processingMask) { \
+      CHECK_END();   \
+      img += pw * x; \
+      CHECK_IMG(0);  \
+   }
+
+/* skip x pixels in source and destination */
+#define SKIP_PIXELS(x) { int wl = x; \
+    while (pixelsLeft <= wl) { \
+      wl -= pixelsLeft;        \
+      SKIP_IMG(pixelsLeft);    \
+      CHECK_END();             \
+      pixelsLeft = *(img++);   \
+      CHECK_IMG(0);            \
+      processingMask = processingMask ? 0 : 1; \
+    }                          \
+    pixelsLeft -= wl;          \
+    SKIP_IMG(wl);              \
+  }
+
+  if (!img)
+    return;
+
+  x = cursorX - pi->hotX;
+  y = cursorY - pi->hotY;
+  w = pi->w;
+  h = pi->h;
+
+  if (!rectsIntersect(x, y, w, h, 
+		      0, 0, si.framebufferWidth, si.framebufferHeight)) {
+    fprintf(stderr, "intersect abort\n");
+    return;
+  }
+
+  pw = myFormat.bitsPerPixel / 8;
+  processingMask = 1;
+  pixelsLeft = *(img++);
+
+/* at this point everything is initialized for the macros */
+
+  /* skip/clip bottom lines */
+  if ((y+h) > si.framebufferHeight) 
+    h = si.framebufferHeight - y;
+
+  /* Skip invisible top lines */
+  while (y < 0) {
+    SKIP_PIXELS(w);
+    y++;
+    h--;
+  }
+
+  /* calculate left/right clipping */
+  if (x < 0) {
+    skipLeft = -x;
+    w += x;
+    x = 0;
+  }
+  else
+    skipLeft = 0;
+
+  if ((x+w) > si.framebufferWidth) {
+    skipRight = (x+w) - si.framebufferWidth;
+    w = si.framebufferWidth - x;
+  }
+  else
+    skipRight = 0;
+
+  fb = (CARD8*) image->data + y * image->bytes_per_line + x * visbpp / 8;
+
+  /* Paint the thing */
+  while (h > 0) {
+    SKIP_PIXELS(skipLeft);
+
+    {
+      CARD8 *fbx = fb;
+      int wl = w;
+      while (pixelsLeft <= wl) {
+	wl -= pixelsLeft;
+	if ((pixelsLeft > 0) && !processingMask) {
+	  int pl = pw * pixelsLeft;
+	  CHECK_IMG(pl);
+	  if (!appData.useBGR233)
+	    memcpy(fbx, img, pl);
+	  else
+	    bgr233cpy(fbx, img, pixelsLeft);
+	  img += pl;
+	}
+
+        CHECK_END();
+	fbx += pixelsLeft * visbpp / 8;
+	pixelsLeft = *(img++);
+
+	CHECK_IMG(0);
+	processingMask = processingMask ? 0 : 1;
+      }
+      pixelsLeft -= wl;
+      if ((wl > 0) && !processingMask) {
+	int pl = pw * wl;
+	CHECK_IMG(pl);
+	if (!appData.useBGR233)
+	  memcpy(fbx, img, pl);
+	else
+	  bgr233cpy(fbx, img, wl);
+	img += pl;
+      }
+    }
+
+    SKIP_PIXELS(skipRight);
+    fb += image->bytes_per_line;
+    h--;
+  }
+  return;
+
+imgError:
+  fprintf(stderr, "Error in softcursor image %d\n", imageIndex);
+  pointerImages[imageIndex].set = 0;
+}
+
+static void discardCursorSavedArea() {
+  if (savedArea)
+    free(savedArea);
+  savedArea = 0;
+}
+
+static void saveCursorSavedArea() {
+  int x, y, w, h;
+
+  if (imageIndex < 0)
+    return;
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&x, &y, &w, &h);
+  if ((w < 1) || (h < 1))
+    return;
+  discardCursorSavedArea();
+  savedArea = malloc(h*image->bytes_per_line);
+  if (!savedArea) {
+    fprintf(stderr,"malloc failed, saving cursor not possible\n");
+    exit(1);
+  }
+  CopyDataFromScreen(savedArea, x, y, w, h);  
+}
+
+void drawCursor() {
+  saveCursorSavedArea();
+  drawCursorImage();
+}
+
+void getBoundingRectCursor(int cx, int cy, int _imageIndex,
+			   int *x, int *y, int *w, int *h) {
+  int nx, ny, nw, nh;
+
+  if ((_imageIndex < 0) || !pointerImages[_imageIndex].set) {
+    *x = 0;
+    *y = 0;
+    *w = 0;
+    *h = 0;
+    return;
+  }
+
+  nx = cx - pointerImages[_imageIndex].hotX;
+  ny = cy - pointerImages[_imageIndex].hotY;
+  nw = pointerImages[_imageIndex].w;
+  nh = pointerImages[_imageIndex].h;
+  if (nx < 0) {
+    nw += nx;
+    nx = 0;
+  }
+  if (ny < 0) {
+    nh += ny;
+    ny = 0;
+  }
+  if ((nx+nw) > si.framebufferWidth)
+    nw = si.framebufferWidth - nx;
+  if ((ny+nh) > si.framebufferHeight)
+    nh = si.framebufferHeight - ny;
+  if ((nw <= 0) || (nh <= 0)) {
+    *x = 0;
+    *y = 0;
+    *w = 0;
+    *h = 0;
+    return;
+  }
+
+  *x = nx;
+  *y = ny;
+  *w = nw;
+  *h = nh;
+}
+
+static SoftCursorState getSoftCursorState(int x, int y, int w, int h) {
+  int cx, cy, cw, ch;
+
+  if (imageIndex < 0)
+    return SOFTCURSOR_UNAFFECTED;
+
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&cx, &cy, &cw, &ch);
+
+  if ((cw == 0) || (ch == 0))
+    return SOFTCURSOR_UNAFFECTED;
+
+  if (!rectsIntersect(x, y, w, h, cx, cy, cw, ch))
+    return SOFTCURSOR_UNAFFECTED;
+  if (rectContains(x, y, w, h, cx, cy, cw, ch))
+    return SOFTCURSOR_UNDER;
+  else
+    return SOFTCURSOR_PART_UNDER;
+}
+
+int rectsIntersect(int x, int y, int w, int h, 
+		   int x2, int y2, int w2, int h2) {
+  if (x2 >= (x+w))
+    return 0;
+  if (y2 >= (y+h))
+    return 0;
+  if ((x2+w2) <= x)
+    return 0;
+  if ((y2+h2) <= y)
+    return 0;
+  return 1;
+}
+
+int rectContains(int outX, int outY, int outW, int outH, 
+		 int inX, int inY, int inW, int inH) {
+  if (inX < outX)
+    return 0;
+  if (inY < outY)
+    return 0;
+  if ((inX+inW) > (outX+outW))
+    return 0;
+  if ((inY+inH) > (outY+outH))
+    return 0;
+  return 1;
+}
+
+void rectsJoin(int *nx1, int *ny1, int *nw1, int *nh1, 
+	       int x2, int y2, int w2, int h2) {
+  int ox, oy, ow, oh;
+  ox = *nx1;
+  oy = *ny1;
+  ow = *nw1;
+  oh = *nh1;
+  
+  if (x2 < ox) {
+    ow += ox - x2;
+    ox = x2;
+  }
+  if (y2 < oy) {
+    oh += oy - y2;
+    oy = y2;
+  }
+  if ((x2+w2) > (ox+ow))
+    ow = (x2+w2) - ox;
+  if ((y2+h2) > (oy+oh))
+    oh = (y2+h2) - oy;
+
+  *nx1 = ox;
+  *ny1 = oy;
+  *nw1 = ow;
+  *nh1 = oh;
+}
+
+XImage *
+CreateShmZoomImage()
+{
+  XImage *_image;
+  XErrorHandler oldXErrorHandler;
+
+  if (!XShmQueryExtension(dpy))
+    return NULL;
+
+  _image = XShmCreateImage(dpy, vis, visdepth, ZPixmap, NULL, &zoomshminfo,
+			  si.framebufferWidth, si.framebufferHeight);
+  if (!_image) return NULL;
+
+  zoomshminfo.shmid = shmget(IPC_PRIVATE,
+			     _image->bytes_per_line * _image->height,
+			     IPC_CREAT|0777);
+
+  if (zoomshminfo.shmid == -1) {
+    XDestroyImage(_image);
+    return NULL;
+  }
+
+  zoomshminfo.shmaddr = _image->data = shmat(zoomshminfo.shmid, 0, 0);
+
+  if (zoomshminfo.shmaddr == (char *)-1) {
+    XDestroyImage(_image);
+    shmctl(zoomshminfo.shmid, IPC_RMID, 0);
+    return NULL;
+  }
+
+  zoomshminfo.readOnly = True;
+
+  oldXErrorHandler = XSetErrorHandler(ShmCreationXErrorHandler);
+  XShmAttach(dpy, &zoomshminfo);
+  XSync(dpy, False);
+  XSetErrorHandler(oldXErrorHandler);
+
+  if (caughtZoomShmError) {
+    XDestroyImage(_image);
+    shmdt(zoomshminfo.shmaddr);
+    shmctl(zoomshminfo.shmid, IPC_RMID, 0);
+    return NULL;
+  }
+
+  needZoomShmCleanup = True;
+
+  fprintf(stderr,"Using shared memory PutImage\n");
+
+  return _image;
+}
+
+
+/*
+ * DrawZoomedScreenRegionX11Thread
+ * Never call from any other desktop.c function, only for X11 thread
+ */
+
+void
+DrawZoomedScreenRegionX11Thread(Window win, int zwidth, int zheight, 
+				int x, int y, int width, int height) {
+  if (!image)
+    return;				
+				
+  if (zwidth > si.framebufferWidth)
+    zwidth = si.framebufferWidth;
+  if (zheight > si.framebufferHeight)
+    zheight = si.framebufferHeight;
+  
+  if (!zoomActive) {
+    ZoomInit();
+    zoomActive = True;
+  }
+  
+  if ((zoomWidth != zwidth) || (zoomHeight != zheight)) {
+    Surface src, dest;
+
+    zoomWidth = zwidth;
+    zoomHeight = zheight;
+  
+    src.w = si.framebufferWidth;
+    src.h = si.framebufferHeight;
+    src.pitch = image->bytes_per_line;
+    src.pixels = image->data;
+    src.BytesPerPixel = visbpp / 8;
+    dest.w = zwidth;
+    dest.h = zheight;
+    dest.pitch = zoomImage->bytes_per_line;
+    dest.pixels = zoomImage->data;
+    dest.BytesPerPixel = visbpp / 8;
+    sge_transform(&src, &dest,  
+		  (float)dest.w/(float)src.w, (float)dest.h/(float)src.h,
+		  0, 0);
+
+    if (useZoomShm) 
+      XShmPutImage(dpy, win, gc, zoomImage, 0, 0, 0, 0, zwidth, zheight, False);
+    else
+      XPutImage(dpy, win, gc, zoomImage, 0, 0, 0, 0, zwidth, zheight);
+    return;
+  }
+
+  if (useZoomShm) 
+    XShmPutImage(dpy, win, gc, zoomImage, x, y, x, y, width, height, False);
+  else
+    XPutImage(dpy, win, gc, zoomImage, x, y, x, y, width, height);
+}
+
+
+static void
+ZoomInit()
+{
+  if (zoomImage)
+    return;
+
+   zoomImage = CreateShmZoomImage(); 
+
+  if (!zoomImage) {
+    useZoomShm = False;
+    zoomImage = XCreateImage(dpy, vis, visdepth, ZPixmap, 0, NULL,
+			     si.framebufferWidth, si.framebufferHeight,
+			     BitmapPad(dpy), 0);
+
+    zoomImage->data = calloc(zoomImage->bytes_per_line * zoomImage->height, 1);
+    if (!zoomImage->data) {
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+  }
+}
+
+static void transformZoomSrc(int six, int siy, int siw, int sih,
+			     int *dix, int *diy, int *diw, int *dih,
+			     int srcW, int dstW, int srcH, int dstH) {
+  double sx, sy, sw, sh;
+  double dx, dy, dw, dh;
+  double wq, hq;
+
+  sx = six; sy = siy;
+  sw = siw; sh = sih;
+
+  wq = ((double)dstW) / (double) srcW;
+  hq = ((double)dstH) / (double) srcH;
+
+  dx = sx * wq;
+  dy = sy * hq;
+  dw = sw * wq;
+  dh = sh * hq;
+  
+  *dix = dx;
+  *diy = dy;
+  *diw = dw+(dx-(int)dx)+0.5;
+  *dih = dh+(dy-(int)dy)+0.5;
+}
+
+static void transformZoomDst(int *six, int *siy, int *siw, int *sih,
+			     int dix, int diy, int diw, int dih,
+			     int srcW, int dstW, int srcH, int dstH) {
+  double sx, sy, sw, sh;
+  double dx, dy, dw, dh;
+  double wq, hq;
+
+  dx = dix; dy = diy;
+  dw = diw; dh = dih;
+
+  wq = ((double)dstW) / (double) srcW;
+  hq = ((double)dstH) / (double) srcH;
+
+  sx = dx / wq;
+  sy = dy / hq;
+  sw = dw / wq;
+  sh = dh / hq;
+  
+  *six = sx;
+  *siy = sy;
+  *siw = sw+(sx-(int)sx)+0.5;
+  *sih = sh+(sy-(int)sy)+0.5;
+}
+
+
+static void ZoomSurfaceSrcCoords(int six, int siy, int siw, int sih,
+				 int *dix, int *diy, int *diw, int *dih,
+				 Surface * src, Surface * dst)
+{
+  int dx, dy, dw, dh;
+  int sx, sy, sw, sh;
+
+  transformZoomSrc(six, siy, siw, sih,
+		   &dx, &dy, &dw, &dh,
+		   src->w, dst->w, src->h, dst->h);
+  dx-=2;
+  dy-=2;
+  dw+=4;
+  dh+=4;
+
+  if (dx < 0)
+    dx = 0;
+  if (dy < 0)
+    dy = 0;
+  if (dx+dw > dst->w)
+    dw = dst->w - dx;
+  if (dy+dh > dst->h)
+    dh = dst->h - dy;
+  
+  transformZoomDst(&sx, &sy, &sw, &sh,
+		   dx, dy, dw, dh,
+		   src->w, dst->w, src->h, dst->h);
+
+  if (sx+sw > src->w)
+    sw = src->w - sx;
+  if (sy+sh > src->h)
+    sh = src->h - sy;
+
+  ZoomSurfaceCoords32(sx, sy, sw, sh, dx, dy, src, dst);
+
+  *dix = dx;
+  *diy = dy;
+  *diw = dw;
+  *dih = dh;
+}
+
+static void ZoomSurfaceCoords32(int sx, int sy, int sw, int sh,
+				int dx, int dy, 
+				Surface * src, Surface * dst)
+{
+  Surface s2;
+
+  s2 = *src;
+  s2.pixels = ((char*)s2.pixels) + (sx * s2.BytesPerPixel) + (sy * src->pitch);
+  s2.w = sw;
+  s2.h = sh;
+  sge_transform(&s2, dst,  
+		(float)dst->w/(float)src->w, (float)dst->h/(float)src->h,
+		dx, dy);
+}
+
+
+#define sge_clip_xmin(pnt) 0
+#define sge_clip_xmax(pnt) pnt->w
+#define sge_clip_ymin(pnt) 0
+#define sge_clip_ymax(pnt) pnt->h
+
+/*==================================================================================
+// Helper function to sge_transform()
+// Returns the bounding box
+//==================================================================================
+*/
+static void _calcRect(Surface *src, Surface *dst, float xscale, float yscale, 
+		      Uint16 qx, Uint16 qy, 
+		      Sint16 *xmin, Sint16 *ymin, Sint16 *xmax, Sint16 *ymax)
+{
+	Sint16 x, y, rx, ry;
+	int i;
+	
+	/* Clip to src surface */
+	Sint16 sxmin = sge_clip_xmin(src);
+	Sint16 sxmax = sge_clip_xmax(src);
+	Sint16 symin = sge_clip_ymin(src);
+	Sint16 symax = sge_clip_ymax(src);
+	Sint16 sx[5];
+	Sint16 sy[4];
+	
+	/* We don't really need fixed-point here
+	 * but why not? */
+	Sint32 ictx = (Sint32) (xscale * 8192.0);
+	Sint32 icty = (Sint32) (yscale * 8192.0);
+
+	sx[0] = sxmin;
+	sx[1] = sxmax;
+	sx[2] = sxmin;
+	sx[3] = sxmax;
+	sy[0] = symin;
+	sy[1] = symax;
+	sy[2] = symax;
+	sy[3] = symin;
+
+	/* Calculate the four corner points */
+	for(i=0; i<4; i++){
+		rx = sx[i];
+		ry = sy[i];
+		
+		x = (Sint16)(((ictx*rx) >> 13) + qx);
+		y = (Sint16)(((icty*ry) >> 13) + qy);
+		
+		
+		if(i==0){
+			*xmax = *xmin = x;
+			*ymax = *ymin = y;
+		}else{
+			if(x>*xmax)
+				*xmax=x;
+			else if(x<*xmin)
+				*xmin=x;
+				
+			if(y>*ymax)
+				*ymax=y;
+			else if(y<*ymin)
+				*ymin=y;
+		}
+	}
+	
+	/* Better safe than sorry...*/
+	*xmin -= 1;
+	*ymin -= 1;
+	*xmax += 1;
+	*ymax += 1;
+	
+	/* Clip to dst surface */
+	if( !dst )
+		return;
+	if( *xmin < sge_clip_xmin(dst) )
+		*xmin = sge_clip_xmin(dst);
+	if( *xmax > sge_clip_xmax(dst) )
+		*xmax = sge_clip_xmax(dst);
+	if( *ymin < sge_clip_ymin(dst) )
+		*ymin = sge_clip_ymin(dst);
+	if( *ymax > sge_clip_ymax(dst) )
+		*ymax = sge_clip_ymax(dst);
+}
+
+
+/*==================================================================================
+** Scale by scale and place at position (qx,qy). 
+** 
+**
+** Developed with the help from Terry Hancock (hancock@earthlink.net)
+**
+**==================================================================================*/
+/* First we need some macros to handle different bpp
+ *  I'm sorry about this... 
+ */
+#define TRANSFORM(UintXX, DIV) \
+	Sint32 src_pitch=src->pitch/DIV; \
+	Sint32 dst_pitch=dst->pitch/DIV; \
+	UintXX *src_row = (UintXX *)src->pixels; \
+	UintXX *dst_row; \
+\
+	for (y=ymin; y<ymax; y++){ \
+		dy = y - qy; \
+\
+		sx = (Sint32)ctdx;  /* Compute source anchor points */ \
+		sy = (Sint32)(cty*dy); \
+\
+		/* Calculate pointer to dst surface */ \
+		dst_row = (UintXX *)dst->pixels + y*dst_pitch; \
+\
+		for (x=xmin; x<xmax; x++){ \
+			rx=(Sint16)(sx >> 13);  /* Convert from fixed-point */ \
+			ry=(Sint16)(sy >> 13); \
+\
+			/* Make sure the source pixel is actually in the source image. */ \
+			if( (rx>=sxmin) && (rx<sxmax) && (ry>=symin) && (ry<symax) ) \
+				*(dst_row + x) = *(src_row + ry*src_pitch + rx); \
+\
+			sx += ctx;  /* Incremental transformations */ \
+		} \
+	}
+	
+	
+/* Interpolated transform */
+#define TRANSFORM_AA(UintXX, DIV) \
+	Sint32 src_pitch=src->pitch/DIV; \
+	Sint32 dst_pitch=dst->pitch/DIV; \
+	UintXX *src_row = (UintXX *)src->pixels; \
+	UintXX *dst_row; \
+	UintXX c1, c2, c3, c4;\
+	Uint32 R, G, B, A=0; \
+	UintXX Rmask = image->red_mask;\
+        UintXX Gmask = image->green_mask;\
+        UintXX Bmask = image->blue_mask;\
+        UintXX Amask = 0;\
+	Uint32 wx, wy;\
+	Uint32 p1, p2, p3, p4;\
+\
+	/* 
+	*  Interpolation:
+	*  We calculate the distances from our point to the four nearest pixels, d1..d4.
+	*  d(a,b) = sqrt(a²+b²) ~= 0.707(a+b)  (Pythagoras (Taylor) expanded around (0.5;0.5))
+	*  
+	*    1  wx 2
+	*     *-|-*  (+ = our point at (x,y))
+	*     | | |  (* = the four nearest pixels)
+	*  wy --+ |  wx = float(x) - int(x)
+	*     |   |  wy = float(y) - int(y)
+	*     *---*
+	*    3     4
+	*  d1 = d(wx,wy)  d2 = d(1-wx,wy)  d3 = d(wx,1-wy)  d4 = d(1-wx,1-wy)
+	*  We now want to weight each pixels importance - it's vicinity to our point:
+	*  w1=d4  w2=d3  w3=d2  w4=d1  (Yes it works... just think a bit about it)
+	*
+	*  If the pixels have the colors c1..c4 then our point should have the color
+	*  c = (w1*c1 + w2*c2 + w3*c3 + w4*c4)/(w1+w2+w3+w4)   (the weighted average)
+	*  but  w1+w2+w3+w4 = 4*0.707  so we might as well write it as
+	*  c = p1*c1 + p2*c2 + p3*c3 + p4*c4  where  p1..p4 = (w1..w4)/(4*0.707)
+	*
+	*  But p1..p4 are fixed point so we can just divide the fixed point constant!
+	*  8192/(4*0.71) = 2897  and we can skip 0.71 too (the division will cancel it everywhere)
+	*  8192/4 = 2048
+	*
+	*  020102: I changed the fixed-point representation for the variables in the weighted average
+	*          to 24.7 to avoid problems with 32bit colors. Everything else is still 18.13. This
+	*          does however not solve the problem with 32bit RGBA colors... 
+	*/\
+\
+	Sint32 one = 2048>>6;   /* 1 in Fixed-point */ \
+	Sint32 two = 2*2048>>6; /* 2 in Fixed-point */ \
+\
+	for (y=ymin; y<ymax; y++){ \
+		dy = y - qy; \
+\
+		sx = (Sint32)(ctdx);  /* Compute source anchor points */ \
+		sy = (Sint32)(cty*dy); \
+\
+		/* Calculate pointer to dst surface */ \
+		dst_row = (UintXX *)dst->pixels + y*dst_pitch; \
+\
+		for (x=xmin; x<xmax; x++){ \
+			rx=(Sint16)(sx >> 13);  /* Convert from fixed-point */ \
+			ry=(Sint16)(sy >> 13); \
+\
+			/* Make sure the source pixel is actually in the source image. */ \
+			if( (rx>=sxmin) && (rx+1<sxmax) && (ry>=symin) && (ry+1<symax) ){ \
+				wx = (sx & 0x00001FFF) >>8;  /* (float(x) - int(x)) / 4 */ \
+				wy = (sy & 0x00001FFF) >>8;\
+\
+				p4 = wx+wy;\
+				p3 = one-wx+wy;\
+				p2 = wx+one-wy;\
+				p1 = two-wx-wy;\
+\
+				c1 = *(src_row + ry*src_pitch + rx);\
+				c2 = *(src_row + ry*src_pitch + rx+1);\
+				c3 = *(src_row + (ry+1)*src_pitch + rx);\
+				c4 = *(src_row + (ry+1)*src_pitch + rx+1);\
+\
+				/* Calculate the average */\
+				R = ((p1*(c1 & Rmask) + p2*(c2 & Rmask) + p3*(c3 & Rmask) + p4*(c4 & Rmask))>>7) & Rmask;\
+				G = ((p1*(c1 & Gmask) + p2*(c2 & Gmask) + p3*(c3 & Gmask) + p4*(c4 & Gmask))>>7) & Gmask;\
+				B = ((p1*(c1 & Bmask) + p2*(c2 & Bmask) + p3*(c3 & Bmask) + p4*(c4 & Bmask))>>7) & Bmask;\
+				if(Amask)\
+					A = ((p1*(c1 & Amask) + p2*(c2 & Amask) + p3*(c3 & Amask) + p4*(c4 & Amask))>>7) & Amask;\
+				\
+				*(dst_row + x) = R | G | B | A;\
+			} \
+			sx += ctx;  /* Incremental transformations */ \
+		} \
+	} 
+
+void sge_transform(Surface *src, Surface *dst, float xscale, float yscale, Uint16 qx, Uint16 qy)
+{
+	Sint32 dy, sx, sy;
+	Sint16 x, y, rx, ry;
+	Rect r;
+
+	Sint32 ctx, cty;
+	Sint16 xmin, xmax, ymin, ymax;
+	Sint16 sxmin, sxmax, symin, symax;
+	Sint32 dx, ctdx;
+
+
+	/* Here we use 18.13 fixed point integer math
+	// Sint32 should have 31 usable bits and one for sign
+	// 2^13 = 8192
+	*/
+
+	/* Check scales */
+	Sint32 maxint = (Sint32)(pow(2, sizeof(Sint32)*8 - 1 - 13));  /* 2^(31-13) */
+
+	r.x = r.y = r.w = r.h = 0;
+	
+	if( xscale == 0 || yscale == 0)
+		return;
+		
+	if( 8192.0/xscale > maxint )
+		xscale =  (float)(8192.0/maxint);
+	else if( 8192.0/xscale < -maxint )
+		xscale =  (float)(-8192.0/maxint);	
+		
+	if( 8192.0/yscale > maxint )
+		yscale =  (float)(8192.0/maxint);
+	else if( 8192.0/yscale < -maxint )
+		yscale =  (float)(-8192.0/maxint);
+
+
+	/* Fixed-point equivalents */
+	ctx = (Sint32)(8192.0/xscale);
+	cty = (Sint32)(8192.0/yscale);
+
+	/* Compute a bounding rectangle */
+	xmin=0; xmax=dst->w; ymin=0; ymax=dst->h;
+	_calcRect(src, dst, xscale, yscale, 
+		  qx, qy, &xmin, &ymin, &xmax, &ymax);	
+
+	/* Clip to src surface */
+	sxmin = sge_clip_xmin(src);
+	sxmax = sge_clip_xmax(src);
+	symin = sge_clip_ymin(src);
+	symax = sge_clip_ymax(src);
+
+	/* Some terms in the transform are constant */
+	dx = xmin - qx;
+	ctdx = ctx*dx;
+	
+	/* Use the correct bpp */
+	if( src->BytesPerPixel == dst->BytesPerPixel){
+		switch( src->BytesPerPixel ){
+			case 1: { /* Assuming 8-bpp */
+				TRANSFORM(Uint8, 1)
+			}
+			break;
+			case 2: { /* Probably 15-bpp or 16-bpp */
+				TRANSFORM_AA(Uint16, 2)
+			}
+			break;
+			case 4: { /* Probably 32-bpp */
+				TRANSFORM_AA(Uint32, 4)
+			}
+			break;
+		}
+	}
+}
+
+void freeDesktopResources() {
+  Cleanup();
+  if (image) {
+    XDestroyImage(image);
+  }
+  if (zoomImage) {
+    XDestroyImage(zoomImage);
+  }
+  if (savedArea)
+    free(savedArea);
+
+  if (gcInited) {
+    XFreeGC(dpy, gc);
+    XFreeGC(dpy, srcGC);
+    XFreeGC(dpy, dstGC);
+  }
+
+  caughtShmError = False;
+  needShmCleanup = False;
+  caughtZoomShmError = False;
+  needZoomShmCleanup = False;
+  gcInited = False;
+  image = NULL;
+  useShm = True;
+  zoomActive = False;
+  zoomImage = NULL;
+  useZoomShm = True;
+  savedArea = NULL;
+}
+
+
+/*
+ * ColorRectangle32
+ * Only used for debugging / visualizing output
+ */
+/*
+static void
+ColorRectangle32(XImage *img, CARD32 fg, int x, int y, int width, int height)
+{
+  int i, h;
+  int scrWidthInBytes = img->bytes_per_line;
+  char *scr;
+  CARD32 *scr32;
+
+  if ((!img) || (!img->data))
+    return;
+
+  scr = (img->data + y * scrWidthInBytes + x * 4);
+    
+  if (!CheckRectangle(x, y, width, height))
+    return;
+
+  for (h = 0; h < height; h++) {
+    scr32 = (CARD32*) scr;
+    for (i = 0; i < width; i++) {
+      CARD32 n = 0;
+      CARD32 p = scr32[i];
+      if (0xff & fg)
+	n |= (((    0xff & p)+(    0xff & fg)) >> 2) & 0xff;
+      else
+	n |= (0xff & p);
+      if (0xff00 & fg)
+	n |= (((  0xff00 & p)+(  0xff00 & fg)) >> 2) & 0xff00;
+      else
+	n |= (0xff00 & p);
+      if (0xff0000 & fg)
+	n |= (((0xff0000 & p)+(0xff0000 & fg)) >> 2) & 0xff0000;
+      else
+	n |= (0xff0000 & p);
+      scr32[i] = n;
+    }
+    scr += scrWidthInBytes;
+  }
+}
+*/
+
diff --git a/krdc/vnc/hextile.c b/krdc/vnc/hextile.c
new file mode 100644
index 00000000..002880af
--- /dev/null
+++ b/krdc/vnc/hextile.c
@@ -0,0 +1,129 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * hextile.c - handle hextile encoding.
+ *
+ * This file shouldn't be compiled directly.  It is included multiple times by
+ * rfbproto.c, each time with a different definition of the macro BPP.  For
+ * each value of BPP, this file defines a function which handles a hextile
+ * encoded rectangle with BPP bits per pixel.
+ */
+
+#define HandleHextileBPP CONCAT2E(HandleHextile,BPP)
+#define CARDBPP CONCAT2E(CARD,BPP)
+#define GET_PIXEL CONCAT2E(GET_PIXEL,BPP)
+#define FillRectangleBPP CONCAT2E(FillRectangle,BPP)
+
+static Bool
+HandleHextileBPP (int rx, int ry, int rw, int rh)
+{
+  CARDBPP bg, fg;
+  int i;
+  CARD8 *ptr;
+  int x, y, w, h;
+  int sx, sy, sw, sh;
+  CARD8 subencoding;
+  CARD8 nSubrects;
+
+  for (y = ry; y < ry+rh; y += 16) {
+    for (x = rx; x < rx+rw; x += 16) {
+      w = h = 16;
+      if (rx+rw - x < 16)
+	w = rx+rw - x;
+      if (ry+rh - y < 16)
+	h = ry+rh - y;
+
+      if (!ReadFromRFBServer((char *)&subencoding, 1))
+	return False;
+
+      if (subencoding & rfbHextileRaw) {
+	if (!ReadFromRFBServer(buffer, w * h * (BPP / 8)))
+	  return False;
+
+	CopyDataToScreen(buffer, x, y, w, h);
+	continue;
+      }
+
+      if (subencoding & rfbHextileBackgroundSpecified)
+	if (!ReadFromRFBServer((char *)&bg, sizeof(bg)))
+	  return False;
+
+      LockFramebuffer();
+      FillRectangleBPP(bg, x, y, w, h);
+
+      if (subencoding & rfbHextileForegroundSpecified)
+	if (!ReadFromRFBServer((char *)&fg, sizeof(fg))) {
+	  UnlockFramebuffer();
+	  return False;
+	}
+
+      if (!(subencoding & rfbHextileAnySubrects)) {
+	UnlockFramebuffer();
+	SyncScreenRegion(x, y, w, h);
+	continue;
+      }
+
+      if (!ReadFromRFBServer((char *)&nSubrects, 1)) {
+	UnlockFramebuffer();
+	return False;
+      }
+
+      ptr = (CARD8 *)buffer;
+
+      if (subencoding & rfbHextileSubrectsColoured) {
+	if (!ReadFromRFBServer(buffer, nSubrects * (2 + (BPP / 8)))) {
+	  UnlockFramebuffer();
+	  return False;
+	}
+
+	for (i = 0; i < nSubrects; i++) {
+	  GET_PIXEL(fg, ptr);
+	  sx = rfbHextileExtractX(*ptr);
+	  sy = rfbHextileExtractY(*ptr);
+	  ptr++;
+	  sw = rfbHextileExtractW(*ptr);
+	  sh = rfbHextileExtractH(*ptr);
+	  ptr++;
+	  FillRectangleBPP(fg, x+sx, y+sy, sw, sh);
+	}
+
+      } else {
+	if (!ReadFromRFBServer(buffer, nSubrects * 2)) {
+	  UnlockFramebuffer();
+	  return False;
+	}
+
+	for (i = 0; i < nSubrects; i++) {
+	  sx = rfbHextileExtractX(*ptr);
+	  sy = rfbHextileExtractY(*ptr);
+	  ptr++;
+	  sw = rfbHextileExtractW(*ptr);
+	  sh = rfbHextileExtractH(*ptr);
+	  ptr++;
+	  FillRectangleBPP(fg, x+sx, y+sy, sw, sh);
+	}
+      }
+      UnlockFramebuffer();
+      SyncScreenRegion(x, y, w, h);
+    }
+  }
+
+  return True;
+}
diff --git a/krdc/vnc/kvncview.cpp b/krdc/vnc/kvncview.cpp
new file mode 100644
index 00000000..1b6a8de2
--- /dev/null
+++ b/krdc/vnc/kvncview.cpp
@@ -0,0 +1,828 @@
+/***************************************************************************
+                          kvncview.cpp  -  main widget
+                             -------------------
+    begin                : Thu Dec 20 15:11:42 CET 2001
+    copyright            : (C) 2001-2003 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "kvncview.h"
+#include "vncprefs.h"
+#include "vnchostpref.h"
+
+#include <kapplication.h>
+#include <kdebug.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kstandarddirs.h>
+#include <kpassdlg.h>
+#include <kdialogbase.h>
+#include <kwallet.h>
+
+#include <qdatastream.h>
+#include <dcopclient.h>
+#include <qclipboard.h>
+#include <qbitmap.h>
+#include <qmutex.h>
+#include <qvbox.h>
+#include <qwaitcondition.h>
+
+#include "vncviewer.h"
+
+#include <X11/Xlib.h>
+
+/*
+ * appData is our application-specific data which can be set by the user with
+ * application resource specs.  The AppData structure is defined in the header
+ * file.
+ */
+AppData appData;
+bool appDataConfigured = false;
+
+Display* dpy;
+
+static KVncView *kvncview;
+
+//Passwords and KWallet data
+extern KWallet::Wallet *wallet;
+bool useKWallet = false;
+static QCString password;
+static QMutex passwordLock;
+static QWaitCondition passwordWaiter;
+
+const unsigned int MAX_SELECTION_LENGTH = 4096;
+
+
+KVncView::KVncView(QWidget *parent,
+		   const char *name,
+		   const QString &_host,
+		   int _port,
+		   const QString &_password,
+		   Quality quality,
+		   DotCursorState dotCursorState,
+		   const QString &encodings) :
+  KRemoteView(parent, name, Qt::WResizeNoErase | Qt::WRepaintNoErase | Qt::WStaticContents),
+  m_cthread(this, m_wthread, m_quitFlag),
+  m_wthread(this, m_quitFlag),
+  m_quitFlag(false),
+  m_enableFramebufferLocking(false),
+  m_scaling(false),
+  m_remoteMouseTracking(false),
+  m_viewOnly(false),
+  m_buttonMask(0),
+  m_host(_host),
+  m_port(_port),
+  m_dontSendCb(false),
+  m_cursorState(dotCursorState)
+{
+	kvncview = this;
+	password = _password.latin1();
+	dpy = qt_xdisplay();
+	setFixedSize(16,16);
+	setFocusPolicy(QWidget::StrongFocus);
+
+	m_cb = QApplication::clipboard();
+	connect(m_cb, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
+	connect(m_cb, SIGNAL(dataChanged()), this, SLOT(clipboardChanged()));
+
+	KStandardDirs *dirs = KGlobal::dirs();
+	QBitmap cursorBitmap(dirs->findResource("appdata",
+						"pics/pointcursor.png"));
+	QBitmap cursorMask(dirs->findResource("appdata",
+					      "pics/pointcursormask.png"));
+	m_cursor = QCursor(cursorBitmap, cursorMask);
+
+	if ((quality != QUALITY_UNKNOWN) ||
+	    !encodings.isNull())
+		configureApp(quality, encodings);
+}
+
+void KVncView::showDotCursor(DotCursorState state) {
+	if (state == m_cursorState)
+		return;
+
+	m_cursorState = state;
+	showDotCursorInternal();
+}
+
+DotCursorState KVncView::dotCursorState() const {
+	return m_cursorState;
+}
+
+void KVncView::showDotCursorInternal() {
+	switch (m_cursorState) {
+	case DOT_CURSOR_ON:
+		setCursor(m_cursor);
+		break;
+	case DOT_CURSOR_OFF:
+		setCursor(QCursor(Qt::BlankCursor));
+		break;
+	case DOT_CURSOR_AUTO:
+		if (m_enableClientCursor)
+			setCursor(QCursor(Qt::BlankCursor));
+		else
+			setCursor(m_cursor);
+		break;
+	}
+}
+
+QString KVncView::host() {
+	return m_host;
+}
+
+int KVncView::port() {
+	return m_port;
+}
+
+void KVncView::startQuitting() {
+	m_quitFlag = true;
+	m_wthread.kick();
+	m_cthread.kick();
+}
+
+bool KVncView::isQuitting() {
+	return m_quitFlag;
+}
+
+void KVncView::configureApp(Quality q, const QString specialEncodings) {
+	appDataConfigured = true;
+	appData.shareDesktop = 1;
+	appData.viewOnly = 0;
+
+	if (q == QUALITY_LOW) {
+		appData.useBGR233 = 1;
+		appData.encodingsString = "background copyrect softcursor tight zlib hextile raw";
+		appData.compressLevel = -1;
+		appData.qualityLevel = 1;
+		appData.dotCursor = 1;
+	}
+	else if (q == QUALITY_MEDIUM) {
+		appData.useBGR233 = 0;
+		appData.encodingsString = "background copyrect softcursor tight zlib hextile raw";
+		appData.compressLevel = -1;
+		appData.qualityLevel = 7;
+		appData.dotCursor = 1;
+	}
+	else if ((q == QUALITY_HIGH) || (q == QUALITY_UNKNOWN)) {
+		appData.useBGR233 = 0;
+		appData.encodingsString = "copyrect softcursor hextile raw";
+		appData.compressLevel = -1;
+		appData.qualityLevel = 9;
+		appData.dotCursor = 1;
+	}
+
+	if (!specialEncodings.isNull())
+		appData.encodingsString = specialEncodings.latin1();
+
+	appData.nColours = 256;
+	appData.useSharedColours = 1;
+	appData.requestedDepth = 0;
+
+	appData.rawDelay = 0;
+	appData.copyRectDelay = 0;
+
+	if (!appData.dotCursor)
+		m_cursorState = DOT_CURSOR_OFF;
+	showDotCursorInternal();
+}
+
+bool KVncView::checkLocalKRfb() {
+	if ( m_host != "localhost" && !m_host.isEmpty() )
+		return true;
+	DCOPClient *d = KApplication::dcopClient();
+
+	int portNum;
+	QByteArray sdata, rdata;
+	QCString replyType;
+	QDataStream arg(sdata, IO_WriteOnly);
+	arg << QString("krfb");
+	if (!d->call ("kded", "kinetd", "port(QString)", sdata, replyType, rdata))
+		return true;
+
+	if (replyType != "int")
+		return true;
+
+	QDataStream answer(rdata, IO_ReadOnly);
+	answer >> portNum;
+
+	if (m_port != portNum)
+		return true;
+
+	setStatus(REMOTE_VIEW_DISCONNECTED);
+	KMessageBox::error(0,
+			   i18n("It is not possible to connect to a local desktop sharing service."),
+			   i18n("Connection Failure"));
+	emit disconnectedError();
+	return false;
+}
+
+bool KVncView::editPreferences( HostPrefPtr host )
+{
+	SmartPtr<VncHostPref> hp( host );
+
+	int ci = hp->quality();
+	bool kwallet = hp->useKWallet();
+
+	// show preferences dialog
+	KDialogBase *dlg = new KDialogBase( 0L, "dlg", true,
+		i18n( "VNC Host Preferences for %1" ).arg( host->host() ),
+		KDialogBase::Ok|KDialogBase::Cancel, KDialogBase::Ok, true );
+
+	QVBox *vbox = dlg->makeVBoxMainWidget();
+	VncPrefs *prefs = new VncPrefs( vbox );
+	QWidget *spacer = new QWidget( vbox );
+	vbox->setStretchFactor( spacer, 10 );
+
+	prefs->setQuality( ci );
+	prefs->setShowPrefs(true);
+	prefs->setUseKWallet(kwallet);
+
+	if ( dlg->exec() == QDialog::Rejected )
+		return false;
+
+	ci = prefs->quality();
+	hp->setAskOnConnect(prefs->showPrefs());
+	hp->setQuality(ci);
+	hp->setUseKWallet(prefs->useKWallet());
+
+	delete dlg;
+	return true;
+}
+
+bool KVncView::start() {
+
+	if (!checkLocalKRfb())
+		return false;
+
+	if (!appDataConfigured) {
+
+		HostPreferences *hps = HostPreferences::instance();
+		SmartPtr<VncHostPref> hp =
+			SmartPtr<VncHostPref>(hps->createHostPref(m_host,
+								 VncHostPref::VncType));
+		if (hp->askOnConnect()) {
+			if (!editPreferences(hp))
+				return false;
+			hps->sync();
+		}
+
+		int ci = hp->quality();
+
+		Quality quality;
+		if (ci == 0)
+			quality = QUALITY_HIGH;
+		else if (ci == 1)
+			quality = QUALITY_MEDIUM;
+		else if (ci == 2)
+			quality = QUALITY_LOW;
+		else {
+			kdDebug() << "Unknown quality";
+				return false;
+		}
+
+		configureApp(quality);
+		useKWallet = hp->useKWallet();
+	}
+
+	setStatus(REMOTE_VIEW_CONNECTING);
+
+	m_cthread.start();
+	setBackgroundMode(Qt::NoBackground);
+	return true;
+}
+
+KVncView::~KVncView()
+{
+	startQuitting();
+	m_cthread.wait();
+	m_wthread.wait();
+	freeResources();
+}
+
+bool KVncView::supportsLocalCursor() const {
+	return true;
+}
+
+bool KVncView::supportsScaling() const {
+	return true;
+}
+
+bool KVncView::scaling() const {
+	return m_scaling;
+}
+
+bool KVncView::viewOnly() {
+	return m_viewOnly;
+}
+
+QSize KVncView::framebufferSize() {
+	return m_framebufferSize;
+}
+
+void KVncView::setViewOnly(bool s) {
+	m_viewOnly = s;
+
+	if (s)
+		setCursor(Qt::ArrowCursor);
+	else
+		showDotCursorInternal();
+}
+
+void KVncView::enableScaling(bool s) {
+	bool os = m_scaling;
+	m_scaling = s;
+	if (s != os) {
+		if (s) {
+			setMaximumSize(m_framebufferSize);
+			setMinimumSize(m_framebufferSize.width()/16,
+				       m_framebufferSize.height()/16);
+		}
+		else
+			setFixedSize(m_framebufferSize);
+	}
+}
+
+void KVncView::paintEvent(QPaintEvent *e) {
+	drawRegion(e->rect().x(),
+		   e->rect().y(),
+		   e->rect().width(),
+		   e->rect().height());
+}
+
+void KVncView::drawRegion(int x, int y, int w, int h) {
+	if (m_scaling)
+		DrawZoomedScreenRegionX11Thread(winId(), width(), height(),
+						x, y, w, h);
+	else
+		DrawScreenRegionX11Thread(winId(), x, y, w, h);
+}
+
+void KVncView::customEvent(QCustomEvent *e)
+{
+	if (e->type() == ScreenRepaintEventType) {
+		ScreenRepaintEvent *sre = (ScreenRepaintEvent*) e;
+		drawRegion(sre->x(), sre->y(),sre->width(), sre->height());
+	}
+	else if (e->type() == ScreenResizeEventType) {
+		ScreenResizeEvent *sre = (ScreenResizeEvent*) e;
+		m_framebufferSize = QSize(sre->width(), sre->height());
+		setFixedSize(m_framebufferSize);
+		emit changeSize(sre->width(), sre->height());
+	}
+	else if (e->type() == DesktopInitEventType) {
+		m_cthread.desktopInit();
+	}
+	else if (e->type() == StatusChangeEventType) {
+		StatusChangeEvent *sce = (StatusChangeEvent*) e;
+		setStatus(sce->status());
+		if (m_status == REMOTE_VIEW_CONNECTED) {
+			emit connected();
+			setFocus();
+			setMouseTracking(true);
+		}
+		else if (m_status == REMOTE_VIEW_DISCONNECTED) {
+			setMouseTracking(false);
+			emit disconnected();
+		}
+		else if (m_status == REMOTE_VIEW_PREPARING) {
+			//Login was successfull: Write KWallet password if necessary.
+			if ( useKWallet && !password.isNull() && wallet && wallet->isOpen() && !wallet->hasEntry(host())) {
+				wallet->writePassword(host(), password);
+			}
+			delete wallet; wallet=0;
+		}
+	}
+	else if (e->type() == PasswordRequiredEventType) {
+		emit showingPasswordDialog(true);
+
+		if (KPasswordDialog::getPassword(password, i18n("Access to the system requires a password.")) != KPasswordDialog::Accepted)
+			password = QCString();
+
+		emit showingPasswordDialog(false);
+
+		passwordLock.lock(); // to guarantee that thread is waiting
+		passwordWaiter.wakeAll();
+		passwordLock.unlock();
+	}
+	else if (e->type() == WalletOpenEventType) {
+		QString krdc_folder = "KRDC-VNC";
+		emit showingPasswordDialog(true); //Bad things happen if you don't do this.
+
+		// Bugfix: Check if wallet has been closed by an outside source
+		if ( wallet && !wallet->isOpen() ) {
+			delete wallet; wallet=0;
+		}
+
+		// Do we need to open the wallet?
+		if ( !wallet ) {
+			QString walletName = KWallet::Wallet::NetworkWallet();
+			wallet = KWallet::Wallet::openWallet(walletName);
+		}
+
+		if (wallet && wallet->isOpen()) {
+			bool walletOK = wallet->hasFolder(krdc_folder);
+			if (walletOK == false) {
+				walletOK = wallet->createFolder(krdc_folder);
+			}
+	
+			if (walletOK == true) {
+				wallet->setFolder(krdc_folder);
+				QString newPass;
+				if ( wallet->hasEntry(kvncview->host()) && !wallet->readPassword(kvncview->host(), newPass) ) {
+					password=newPass.latin1();
+				}
+			}
+		}
+
+		passwordLock.lock(); // to guarantee that thread is waiting
+		passwordWaiter.wakeAll();
+		passwordLock.unlock();
+
+		emit showingPasswordDialog(false);
+	}
+	else if (e->type() == FatalErrorEventType) {
+		FatalErrorEvent *fee = (FatalErrorEvent*) e;
+		setStatus(REMOTE_VIEW_DISCONNECTED);
+		switch (fee->errorCode()) {
+		case ERROR_CONNECTION:
+			KMessageBox::error(0,
+					   i18n("Connection attempt to host failed."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_PROTOCOL:
+			KMessageBox::error(0,
+					   i18n("Remote host is using an incompatible protocol."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_IO:
+			KMessageBox::error(0,
+					   i18n("The connection to the host has been interrupted."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_SERVER_BLOCKED:
+			KMessageBox::error(0,
+					   i18n("Connection failed. The server does not accept new connections."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_NAME:
+			KMessageBox::error(0,
+					   i18n("Connection failed. A server with the given name cannot be found."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_NO_SERVER:
+			KMessageBox::error(0,
+					   i18n("Connection failed. No server running at the given address and port."),
+					   i18n("Connection Failure"));
+			break;
+		case ERROR_AUTHENTICATION:
+			//Login failed: Remove wallet entry if there is one.
+			if ( useKWallet && wallet && wallet->isOpen() && wallet->hasEntry(host()) ) {
+				wallet->removeEntry(host());
+			}
+			KMessageBox::error(0,
+					   i18n("Authentication failed. Connection aborted."),
+					   i18n("Authentication Failure"));
+			break;
+		default:
+			KMessageBox::error(0,
+					   i18n("Unknown error."),
+					   i18n("Unknown Error"));
+			break;
+		}
+		emit disconnectedError();
+	}
+	else if (e->type() == BeepEventType) {
+		QApplication::beep();
+	}
+	else if (e->type() == ServerCutEventType) {
+		ServerCutEvent *sce = (ServerCutEvent*) e;
+		QString ctext = QString::fromUtf8(sce->bytes(), sce->length());
+		m_dontSendCb = true;
+		m_cb->setText(ctext, QClipboard::Clipboard);
+		m_cb->setText(ctext, QClipboard::Selection);
+		m_dontSendCb = false;
+	}
+	else if (e->type() == MouseStateEventType) {
+		MouseStateEvent *mse = (MouseStateEvent*) e;
+		emit mouseStateChanged(mse->x(), mse->y(), mse->buttonMask());
+		bool show = m_plom.handlePointerEvent(mse->x(), mse->y());
+		if (m_cursorState != DOT_CURSOR_ON)
+			showDotCursor(show ? DOT_CURSOR_AUTO : DOT_CURSOR_OFF);
+	}
+}
+
+void KVncView::mouseEvent(QMouseEvent *e) {
+	if (m_status != REMOTE_VIEW_CONNECTED)
+		return;
+	if (m_viewOnly)
+		return;
+
+	if ( e->type() != QEvent::MouseMove ) {
+		if ( (e->type() == QEvent::MouseButtonPress) ||
+                     (e->type() == QEvent::MouseButtonDblClick)) {
+			if ( e->button() & LeftButton )
+				m_buttonMask |= 0x01;
+			if ( e->button() & MidButton )
+				m_buttonMask |= 0x02;
+			if ( e->button() & RightButton )
+				m_buttonMask |= 0x04;
+		}
+		else if ( e->type() == QEvent::MouseButtonRelease ) {
+			if ( e->button() & LeftButton )
+				m_buttonMask &= 0xfe;
+			if ( e->button() & MidButton )
+				m_buttonMask &= 0xfd;
+			if ( e->button() & RightButton )
+				m_buttonMask &= 0xfb;
+		}
+	}
+
+	int x = e->x();
+	int y = e->y();
+	m_plom.registerPointerState(x, y);
+	if (m_scaling) {
+		x = (x * m_framebufferSize.width()) / width();
+		y = (y * m_framebufferSize.height()) / height();
+	}
+	m_wthread.queueMouseEvent(x, y, m_buttonMask);
+
+	if (m_enableClientCursor)
+		DrawCursorX11Thread(x, y); // in rfbproto.c
+}
+
+void KVncView::mousePressEvent(QMouseEvent *e) {
+	mouseEvent(e);
+	e->accept();
+}
+
+void KVncView::mouseDoubleClickEvent(QMouseEvent *e) {
+	mouseEvent(e);
+	e->accept();
+}
+
+void KVncView::mouseReleaseEvent(QMouseEvent *e) {
+	mouseEvent(e);
+	e->accept();
+}
+
+void KVncView::mouseMoveEvent(QMouseEvent *e) {
+	mouseEvent(e);
+	e->ignore();
+}
+
+void KVncView::wheelEvent(QWheelEvent *e) {
+	if (m_status != REMOTE_VIEW_CONNECTED)
+		return;
+	if (m_viewOnly)
+		return;
+
+	int eb = 0;
+	if ( e->delta() < 0 )
+		eb |= 0x10;
+	else
+		eb |= 0x8;
+
+	int x = e->pos().x();
+	int y = e->pos().y();
+	if (m_scaling) {
+		x = (x * m_framebufferSize.width()) / width();
+		y = (y * m_framebufferSize.height()) / height();
+	}
+	m_wthread.queueMouseEvent(x, y, eb|m_buttonMask);
+	m_wthread.queueMouseEvent(x, y, m_buttonMask);
+	e->accept();
+}
+
+void KVncView::pressKey(XEvent *xe) {
+	KKeyNative k(xe);
+	uint mod = k.mod();
+	if (mod & KKeyNative::modX(KKey::SHIFT))
+		m_wthread.queueKeyEvent(XK_Shift_L, true);
+	if (mod & KKeyNative::modX(KKey::CTRL))
+		m_wthread.queueKeyEvent(XK_Control_L, true);
+	if (mod & KKeyNative::modX(KKey::ALT))
+		m_wthread.queueKeyEvent(XK_Alt_L, true);
+	if (mod & KKeyNative::modX(KKey::WIN))
+		m_wthread.queueKeyEvent(XK_Meta_L, true);
+
+	m_wthread.queueKeyEvent(k.sym(), true);
+	m_wthread.queueKeyEvent(k.sym(), false);
+
+	if (mod & KKeyNative::modX(KKey::WIN))
+		m_wthread.queueKeyEvent(XK_Meta_L, false);
+	if (mod & KKeyNative::modX(KKey::ALT))
+		m_wthread.queueKeyEvent(XK_Alt_L, false);
+	if (mod & KKeyNative::modX(KKey::CTRL))
+		m_wthread.queueKeyEvent(XK_Control_L, false);
+	if (mod & KKeyNative::modX(KKey::SHIFT))
+		m_wthread.queueKeyEvent(XK_Shift_L, false);
+
+	m_mods.clear();
+}
+
+bool KVncView::x11Event(XEvent *e) {
+	bool pressed;
+	if (e->type == KeyPress)
+		pressed = true;
+	else if (e->type == KeyRelease)
+		pressed = false;
+	else
+		return QWidget::x11Event(e);
+
+	if (!m_viewOnly) {
+		unsigned int s = KKeyNative(e).sym();
+
+		switch (s) {
+		case XK_Meta_L:
+		case XK_Alt_L:
+		case XK_Control_L:
+		case XK_Shift_L:
+		case XK_Meta_R:
+		case XK_Alt_R:
+		case XK_Control_R:
+		case XK_Shift_R:
+			if (pressed)
+				m_mods[s] = true;
+			else if (m_mods.contains(s))
+				m_mods.remove(s);
+			else
+				unpressModifiers();
+		}
+		m_wthread.queueKeyEvent(s, pressed);
+	}
+	return true;
+}
+
+void KVncView::unpressModifiers() {
+	QValueList<unsigned int> keys = m_mods.keys();
+	QValueList<unsigned int>::const_iterator it = keys.begin();
+	while (it != keys.end()) {
+		m_wthread.queueKeyEvent(*it, false);
+		it++;
+	}
+	m_mods.clear();
+}
+
+void KVncView::focusOutEvent(QFocusEvent *) {
+	unpressModifiers();
+}
+
+QSize KVncView::sizeHint() {
+	return maximumSize();
+}
+
+void KVncView::setRemoteMouseTracking(bool s) {
+	m_remoteMouseTracking = s;
+}
+
+bool KVncView::remoteMouseTracking() {
+	return m_remoteMouseTracking;
+}
+
+void KVncView::clipboardChanged() {
+	if (m_status != REMOTE_VIEW_CONNECTED)
+		return;
+
+	if (m_cb->ownsClipboard() || m_dontSendCb)
+		return;
+
+	QString text = m_cb->text(QClipboard::Clipboard);
+	if (text.length() > MAX_SELECTION_LENGTH)
+		return;
+
+	m_wthread.queueClientCut(text);
+}
+
+void KVncView::selectionChanged() {
+	if (m_status != REMOTE_VIEW_CONNECTED)
+		return;
+
+	if (m_cb->ownsSelection() || m_dontSendCb)
+		return;
+
+	QString text = m_cb->text(QClipboard::Selection);
+	if (text.length() > MAX_SELECTION_LENGTH)
+		return;
+
+	m_wthread.queueClientCut(text);
+}
+
+
+void KVncView::lockFramebuffer() {
+	if (m_enableFramebufferLocking)
+		m_framebufferLock.lock();
+}
+
+void KVncView::unlockFramebuffer() {
+	if (m_enableFramebufferLocking)
+		m_framebufferLock.unlock();
+}
+
+void KVncView::enableClientCursor(bool enable) {
+	if (enable) {
+		m_enableFramebufferLocking = true; // cant be turned off
+	}
+	m_enableClientCursor = enable;
+	lockFramebuffer();
+	showDotCursorInternal();
+	unlockFramebuffer();
+}
+
+/*!
+	\brief Get a password for this host.
+	Tries to get a password from the url or wallet if at all possible. If
+	both of these fail, it then asks the user to enter a password.
+	\note Lots of dialogs can be popped up during this process. The thread
+	locks and signals are there to protect against deadlocks and other
+	horribleness. Be careful making changes here. 
+*/
+int getPassword(char *passwd, int pwlen) {
+	int retV = 0;
+
+	//Prepare the system
+	passwordLock.lock();
+
+	//Try #1: Did the user give a password in the URL?
+	if (!password.isNull()) {
+		retV = 1; //got it!
+	}
+
+	//Try #2: Is there something in the wallet?
+	if ( !retV && useKWallet ) {
+		QApplication::postEvent(kvncview, new WalletOpenEvent());
+		passwordWaiter.wait(&passwordLock); //block
+		if (!password.isNull()) retV = 1; //got it!
+	}
+
+	//Last try: Ask the user
+	if (!retV) {
+		QApplication::postEvent(kvncview, new PasswordRequiredEvent());
+		passwordWaiter.wait(&passwordLock); //block
+		if (!password.isNull()) retV = 1; //got it!
+	}
+
+	//Process the password if we got it, clear it if we didn't
+	if (retV) {
+		strncpy(passwd, (const char*)password, pwlen);
+	} else {
+		passwd[0] = 0;
+	}
+
+	//Pack up and go home
+	passwordLock.unlock();
+	if (!retV) kvncview->startQuitting();
+
+	return retV;
+}
+
+extern int isQuitFlagSet() {
+	return kvncview->isQuitting() ? 1 : 0;
+}
+
+extern void DrawScreenRegion(int x, int y, int width, int height) {
+/*	KApplication::kApplication()->lock();
+	kvncview->drawRegion(x, y, width, height);
+	KApplication::kApplication()->unlock();
+*/
+	QApplication::postEvent(kvncview, new ScreenRepaintEvent(x, y, width, height));
+}
+
+// call only from x11 thread!
+extern void DrawAnyScreenRegionX11Thread(int x, int y, int width, int height) {
+	kvncview->drawRegion(x, y, width, height);
+}
+
+extern void EnableClientCursor(int enable) {
+	kvncview->enableClientCursor(enable);
+}
+
+extern void LockFramebuffer() {
+  	kvncview->lockFramebuffer();
+}
+
+extern void UnlockFramebuffer() {
+  	kvncview->unlockFramebuffer();
+}
+
+extern void beep() {
+	QApplication::postEvent(kvncview, new BeepEvent());
+}
+
+extern void newServerCut(char *bytes, int length) {
+	QApplication::postEvent(kvncview, new ServerCutEvent(bytes, length));
+}
+
+extern void postMouseEvent(int x, int y, int buttonMask) {
+	QApplication::postEvent(kvncview, new MouseStateEvent(x, y, buttonMask));
+}
+
+#include "kvncview.moc"
diff --git a/krdc/vnc/kvncview.h b/krdc/vnc/kvncview.h
new file mode 100644
index 00000000..1b961f3d
--- /dev/null
+++ b/krdc/vnc/kvncview.h
@@ -0,0 +1,121 @@
+/***************************************************************************
+                  kvncview.h  -  widget that shows the vnc client
+                             -------------------
+    begin                : Thu Dec 20 15:11:42 CET 2001
+    copyright            : (C) 2001-2003 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef KVNCVIEW_H
+#define KVNCVIEW_H
+
+#include "kremoteview.h"
+#include <qcursor.h>
+#include <qmap.h>
+
+#include "pointerlatencyometer.h"
+#include "hostpreferences.h"
+#include "vnctypes.h"
+#include "threads.h"
+
+class QClipBoard;
+
+class KVncView : public KRemoteView
+{
+	Q_OBJECT
+private:
+	ControllerThread m_cthread;
+	WriterThread m_wthread;
+	volatile bool m_quitFlag; // if set: all threads should die ASAP
+	QMutex m_framebufferLock;
+	bool m_enableFramebufferLocking;
+	bool m_enableClientCursor;
+
+	QSize m_framebufferSize;
+	bool m_scaling;
+	bool m_remoteMouseTracking;
+	bool m_viewOnly;
+
+	int m_buttonMask;
+	QMap<unsigned int,bool> m_mods;
+
+	QString m_host;
+	int m_port;
+
+	QClipboard *m_cb;
+	bool m_dontSendCb;
+	QCursor m_cursor;
+	DotCursorState m_cursorState;
+	PointerLatencyOMeter m_plom;
+
+	void mouseEvent(QMouseEvent*);
+	unsigned long toKeySym(QKeyEvent *k);
+	bool checkLocalKRfb();
+	void paintMessage(const QString &msg);
+	void showDotCursorInternal();
+	void unpressModifiers();
+
+protected:
+	void paintEvent(QPaintEvent*);
+	void customEvent(QCustomEvent*);
+	void mousePressEvent(QMouseEvent*);
+	void mouseDoubleClickEvent(QMouseEvent*);
+	void mouseReleaseEvent(QMouseEvent*);
+	void mouseMoveEvent(QMouseEvent*);
+	void wheelEvent(QWheelEvent *);
+	void focusOutEvent(QFocusEvent *);
+	bool x11Event(XEvent*);
+
+public:
+	KVncView(QWidget* parent=0, const char *name=0,
+		 const QString &host = QString(""), int port = 5900,
+		 const QString &password = QString::null,
+		 Quality quality = QUALITY_UNKNOWN,
+		 DotCursorState dotCursorState = DOT_CURSOR_AUTO,
+		 const QString &encodings = QString::null);
+	~KVncView();
+	QSize sizeHint();
+	void drawRegion(int x, int y, int w, int h);
+	void lockFramebuffer();
+	void unlockFramebuffer();
+	void enableClientCursor(bool enable);
+	virtual bool scaling() const;
+	virtual bool supportsScaling() const;
+	virtual bool supportsLocalCursor() const;
+	virtual QSize framebufferSize();
+	void setRemoteMouseTracking(bool s);
+	bool remoteMouseTracking();
+	void configureApp(Quality q, const QString specialEncodings = QString::null);
+	void showDotCursor(DotCursorState state);
+	DotCursorState dotCursorState() const;
+	virtual void startQuitting();
+	virtual bool isQuitting();
+	virtual QString host();
+	virtual int port();
+	virtual bool start();
+
+	virtual bool viewOnly();
+
+	static bool editPreferences( HostPrefPtr );
+
+public slots:
+	virtual void enableScaling(bool s);
+	virtual void setViewOnly(bool s);
+	virtual void pressKey(XEvent *k);
+
+
+private slots:
+	void clipboardChanged();
+	void selectionChanged();
+};
+
+#endif
diff --git a/krdc/vnc/pointerlatencyometer.h b/krdc/vnc/pointerlatencyometer.h
new file mode 100644
index 00000000..559536b2
--- /dev/null
+++ b/krdc/vnc/pointerlatencyometer.h
@@ -0,0 +1,83 @@
+/***************************************************************************
+                  pointerlatencyometer.h  - measuring pointer latency
+                             -------------------
+    begin                : Wed Jun 30 12:04:44 CET 2002
+    copyright            : (C) 2002-2003 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <qdatetime.h>
+#include <kdebug.h>
+
+struct PointerState {
+	int x, y;
+	QTime timestamp;
+};
+
+class PointerLatencyOMeter {
+private:
+	enum { stateCapacity = 30, maximumLatency = 1000 };
+	PointerState states[stateCapacity];
+	int firstState, stateNum;
+	float last3Latency, last20Latency;
+
+public:
+	PointerLatencyOMeter() :
+		firstState(0),
+		stateNum(0),
+		last3Latency(125),
+		last20Latency(25) {
+	}
+	
+	// registers a client pointer state
+	void registerPointerState(int x, int y) {
+		if (stateNum == stateCapacity)
+			stateNum--;
+		if (firstState == 0)
+			firstState = stateCapacity-1;
+		else
+			firstState--;
+		states[firstState].x = x;
+		states[firstState].y = y;
+		states[firstState].timestamp.start();
+		stateNum++;
+	}
+
+	/* Returns true if pointer should be visible */
+	bool registerLatency(int msecs) {
+		last3Latency = ((last3Latency * 2.0) + msecs) / 3.0;
+		last20Latency = ((last20Latency * 19.0) + msecs) / 20.0;
+
+		if (msecs >= maximumLatency) 
+			return true;
+		if (last3Latency > (1000/4))
+			return true;
+		return last20Latency > (1000/12);
+	}
+
+	// Called with server-side coordinates.
+	// Returns true if pointer should be visible
+	bool handlePointerEvent(int x, int y) {
+		for (int i = stateNum-1; i >= 0; i--) {
+			int idx = (i+firstState) % stateCapacity;
+			if ((states[idx].x != x) ||
+			    (states[idx].y != y)) 
+				continue;
+			
+			stateNum = i;
+			int l = states[idx].timestamp.elapsed();
+			return registerLatency((l > maximumLatency) ? maximumLatency : l);
+		}
+		return true;
+	}
+
+};
diff --git a/krdc/vnc/rfbproto.c b/krdc/vnc/rfbproto.c
new file mode 100644
index 00000000..e9ed5764
--- /dev/null
+++ b/krdc/vnc/rfbproto.c
@@ -0,0 +1,1335 @@
+/*
+ *  Copyright (C) 2002, Tim Jansen.  All Rights Reserved.
+ *  Copyright (C) 2000-2002 Constantin Kaplinsky.  All Rights Reserved.
+ *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * rfbproto.c - functions to deal with client side of RFB protocol.
+ * tim@tjansen.de: - added softcursor encoding
+ *                 - changed various things for krdc
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include <pwd.h>
+#include "vncviewer.h"
+#include "vncauth.h"
+#include <zlib.h>
+#include <jpeglib.h>
+
+static Bool HandleHextile8(int rx, int ry, int rw, int rh);
+static Bool HandleHextile16(int rx, int ry, int rw, int rh);
+static Bool HandleHextile32(int rx, int ry, int rw, int rh);
+static Bool HandleZlib8(int rx, int ry, int rw, int rh);
+static Bool HandleZlib16(int rx, int ry, int rw, int rh);
+static Bool HandleZlib32(int rx, int ry, int rw, int rh);
+static Bool HandleTight8(int rx, int ry, int rw, int rh);
+static Bool HandleTight16(int rx, int ry, int rw, int rh);
+static Bool HandleTight32(int rx, int ry, int rw, int rh);
+
+static long ReadCompactLen (void);
+
+static void JpegInitSource(j_decompress_ptr cinfo);
+static boolean JpegFillInputBuffer(j_decompress_ptr cinfo);
+static void JpegSkipInputData(j_decompress_ptr cinfo, long num_bytes);
+static void JpegTermSource(j_decompress_ptr cinfo);
+static void JpegSetSrcManager(j_decompress_ptr cinfo, CARD8 *compressedData,
+                              int compressedLen);
+
+
+#define RGB24_TO_PIXEL(bpp,r,g,b)                                       \
+   ((((CARD##bpp)(r) & 0xFF) * myFormat.redMax + 127) / 255             \
+    << myFormat.redShift |                                              \
+    (((CARD##bpp)(g) & 0xFF) * myFormat.greenMax + 127) / 255           \
+    << myFormat.greenShift |                                            \
+    (((CARD##bpp)(b) & 0xFF) * myFormat.blueMax + 127) / 255            \
+    << myFormat.blueShift)
+
+int rfbsock;
+char *desktopName;
+rfbPixelFormat myFormat;
+rfbServerInitMsg si;
+
+int endianTest = 1;
+
+/*
+ * Softcursor variables
+ */
+
+int cursorX, cursorY;
+int imageIndex = -1;
+
+PointerImage pointerImages[rfbSoftCursorMaxImages];
+
+
+/*  Hextile assumes it is big enough to hold 16 * 16 * 32 bits.
+   Tight encoding assumes BUFFER_SIZE is at least 16384 bytes. */
+
+#define BUFFER_SIZE (16384)
+static char buffer[BUFFER_SIZE];
+
+
+/* The zlib encoding requires expansion/decompression/deflation of the
+   compressed data in the "buffer" above into another, result buffer.
+   However, the size of the result buffer can be determined precisely
+   based on the bitsPerPixel, height and width of the rectangle.  We
+   allocate this buffer one time to be the full size of the buffer. */
+
+static int raw_buffer_size = -1;
+static char *raw_buffer = NULL;
+
+static z_stream decompStream;
+static Bool decompStreamInited = False;
+
+
+/*
+ * Variables for the ``tight'' encoding implementation.
+ */
+
+/* Separate buffer for compressed data. */
+#define ZLIB_BUFFER_SIZE 512
+static char zlib_buffer[ZLIB_BUFFER_SIZE];
+
+/* Four independent compression streams for zlib library. */
+static z_stream zlibStream[4];
+static Bool zlibStreamActive[4] = {
+  False, False, False, False
+};
+
+/* Filter stuff. Should be initialized by filter initialization code. */
+static Bool cutZeros;
+static int rectWidth, rectColors;
+static char tightPalette[256*4];
+static CARD8 tightPrevRow[2048*3*sizeof(CARD16)];
+
+/* JPEG decoder state. */
+static Bool jpegError;
+
+/* Maximum length for the cut buffer (16 MB)*/
+#define MAX_CUTBUFFER (1024*1024*16)
+
+/* Maximum length for the strings (64 kB)*/
+#define MAX_STRING (1024*64)
+
+/* Maximum length for the strings (32 MB)*/
+#define MAX_JPEG_SIZE (1024*1024*32)
+
+
+/*
+ * ConnectToRFBServer.
+ */
+
+int
+ConnectToRFBServer(const char *hostname, int port)
+{
+  unsigned int host;
+
+  if (!StringToIPAddr(hostname, &host)) {
+    fprintf(stderr,"Couldn't convert '%s' to host address\n", hostname);
+    return -(int)INIT_NAME_RESOLUTION_FAILURE;
+  }
+
+  rfbsock = ConnectToTcpAddr(host, port);
+  if (rfbsock < 0) {
+    fprintf(stderr,"Unable to connect to VNC server\n");
+  }
+
+  return rfbsock;
+}
+
+
+/*
+ * InitialiseRFBConnection.
+ */
+
+enum InitStatus
+InitialiseRFBConnection()
+{
+  rfbProtocolVersionMsg pv;
+  int major,minor;
+  CARD32 authScheme, reasonLen, authResult;
+  char *reason;
+  CARD8 challenge[CHALLENGESIZE];
+  char passwd[9];
+  int i;
+  rfbClientInitMsg ci;
+
+  /* if the connection is immediately closed, don't report anything, so
+       that pmw's monitor can make test connections */
+
+  if (!ReadFromRFBServer(pv, sz_rfbProtocolVersionMsg)) return INIT_SERVER_BLOCKED;
+
+  errorMessageOnReadFailure = True;
+
+  pv[sz_rfbProtocolVersionMsg] = 0;
+
+  if (sscanf(pv,rfbProtocolVersionFormat,&major,&minor) != 2) {
+    fprintf(stderr,"Not a valid VNC server\n");
+    return INIT_PROTOCOL_FAILURE;
+  }
+
+  fprintf(stderr,"VNC server supports protocol version %d.%d (viewer %d.%d)\n",
+	  major, minor, rfbProtocolMajorVersion, rfbProtocolMinorVersion);
+
+  major = rfbProtocolMajorVersion;
+  minor = rfbProtocolMinorVersion;
+
+  sprintf(pv,rfbProtocolVersionFormat,major,minor);
+
+  if (!WriteExact(rfbsock, pv, sz_rfbProtocolVersionMsg)) return INIT_CONNECTION_FAILED;
+
+  if (!ReadFromRFBServer((char *)&authScheme, 4)) return INIT_CONNECTION_FAILED;
+
+  authScheme = Swap32IfLE(authScheme);
+
+  switch (authScheme) {
+
+  case rfbConnFailed:
+    if (!ReadFromRFBServer((char *)&reasonLen, 4)) return INIT_CONNECTION_FAILED;
+    reasonLen = Swap32IfLE(reasonLen);
+
+    if (reasonLen > MAX_STRING) {
+      fprintf(stderr, "Connection failure reason too long.\n");
+      return INIT_CONNECTION_FAILED;
+    }
+      
+    reason = malloc(reasonLen);
+    if (!reason)
+      return INIT_CONNECTION_FAILED;
+      
+    if (!ReadFromRFBServer(reason, reasonLen)) return INIT_CONNECTION_FAILED;
+
+    fprintf(stderr,"VNC connection failed: %.*s\n",(int)reasonLen, reason);
+    free(reason);
+    return INIT_CONNECTION_FAILED;
+
+  case rfbNoAuth:
+    fprintf(stderr,"No authentication needed\n");
+    break;
+
+  case rfbVncAuth:
+    if (!ReadFromRFBServer((char *)challenge, CHALLENGESIZE)) return INIT_CONNECTION_FAILED;
+
+    if (!getPassword(passwd, 8))
+      return INIT_ABORTED;
+
+    passwd[8] = '\0';
+
+    vncEncryptBytes(challenge, passwd);
+
+	/* Lose the password from memory */
+    for (i = strlen(passwd); i >= 0; i--) {
+      passwd[i] = '\0';
+    }
+
+    if (!WriteExact(rfbsock, (char *)challenge, CHALLENGESIZE)) return INIT_CONNECTION_FAILED;
+
+    if (!ReadFromRFBServer((char *)&authResult, 4)) return INIT_CONNECTION_FAILED;
+
+    authResult = Swap32IfLE(authResult);
+
+    switch (authResult) {
+    case rfbVncAuthOK:
+      fprintf(stderr,"VNC authentication succeeded\n");
+      break;
+    case rfbVncAuthFailed:
+      fprintf(stderr,"VNC authentication failed\n");
+      return INIT_AUTHENTICATION_FAILED;
+    case rfbVncAuthTooMany:
+      fprintf(stderr,"VNC authentication failed - too many tries\n");
+      return INIT_AUTHENTICATION_FAILED;
+    default:
+      fprintf(stderr,"Unknown VNC authentication result: %d\n",
+	      (int)authResult);
+      return INIT_CONNECTION_FAILED;
+    }
+    break;
+
+  default:
+    fprintf(stderr,"Unknown authentication scheme from VNC server: %d\n",
+	    (int)authScheme);
+    return INIT_CONNECTION_FAILED;
+  }
+
+  ci.shared = (appData.shareDesktop ? 1 : 0);
+
+  if (!WriteExact(rfbsock, (char *)&ci, sz_rfbClientInitMsg)) return INIT_CONNECTION_FAILED;
+
+  if (!ReadFromRFBServer((char *)&si, sz_rfbServerInitMsg)) return INIT_CONNECTION_FAILED;
+
+  si.framebufferWidth = Swap16IfLE(si.framebufferWidth);
+  si.framebufferHeight = Swap16IfLE(si.framebufferHeight);
+  si.format.redMax = Swap16IfLE(si.format.redMax);
+  si.format.greenMax = Swap16IfLE(si.format.greenMax);
+  si.format.blueMax = Swap16IfLE(si.format.blueMax);
+  si.nameLength = Swap32IfLE(si.nameLength);
+
+  if ((si.framebufferWidth*si.framebufferHeight) > (4096*4096))
+    return INIT_CONNECTION_FAILED;
+
+  if (si.nameLength > MAX_STRING) {
+    fprintf(stderr, "Display name too long.\n");  
+    return INIT_CONNECTION_FAILED;
+  }
+
+  desktopName = malloc(si.nameLength + 1);
+  if (!desktopName) {
+    fprintf(stderr, "Error allocating memory for desktop name, %lu bytes\n",
+            (unsigned long)si.nameLength);
+    return INIT_CONNECTION_FAILED;
+  }
+
+  if (!ReadFromRFBServer(desktopName, si.nameLength)) return INIT_CONNECTION_FAILED;
+
+  desktopName[si.nameLength] = 0;
+
+  fprintf(stderr,"Desktop name \"%s\"\n",desktopName);
+
+  fprintf(stderr,"Connected to VNC server, using protocol version %d.%d\n",
+	  rfbProtocolMajorVersion, rfbProtocolMinorVersion);
+
+  fprintf(stderr,"VNC server default format:\n");
+  PrintPixelFormat(&si.format);
+
+  return INIT_OK;
+}
+
+
+/*
+ * SetFormatAndEncodings.
+ */
+
+Bool
+SetFormatAndEncodings()
+{
+  rfbSetPixelFormatMsg spf;
+  char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4];
+  rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf;
+  CARD32 *encs = (CARD32 *)(&buf[sz_rfbSetEncodingsMsg]);
+  int len = 0;
+  Bool requestCompressLevel = False;
+  Bool requestQualityLevel = False;
+  Bool requestLastRectEncoding = False;
+
+  spf.type = rfbSetPixelFormat;
+  spf.pad1 = 0;
+  spf.pad2 = 0;
+  spf.format = myFormat;
+  spf.format.redMax = Swap16IfLE(spf.format.redMax);
+  spf.format.greenMax = Swap16IfLE(spf.format.greenMax);
+  spf.format.blueMax = Swap16IfLE(spf.format.blueMax);
+
+  if (!WriteExact(rfbsock, (char *)&spf, sz_rfbSetPixelFormatMsg))
+    return False;
+
+  se->type = rfbSetEncodings;
+  se->pad = 0;
+  se->nEncodings = 0;
+
+  if (appData.encodingsString) {
+    const char *encStr = appData.encodingsString;
+    int encStrLen;
+    do {
+      char *nextEncStr = strchr(encStr, ' ');
+      if (nextEncStr) {
+	encStrLen = nextEncStr - encStr;
+	nextEncStr++;
+      } else {
+	encStrLen = strlen(encStr);
+      }
+
+      if (strncasecmp(encStr,"raw",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw);
+      } else if (strncasecmp(encStr,"copyrect",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect);
+      } else if (strncasecmp(encStr,"softcursor",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingSoftCursor);
+        /* if server supports SoftCursor, it will ignore X/RichCursor 
+	 * and PointerPos */
+        encs[se->nEncodings++] = Swap32IfLE(rfbEncodingXCursor);
+        encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRichCursor);
+        encs[se->nEncodings++] = Swap32IfLE(rfbEncodingPointerPos);
+      } else if (strncasecmp(encStr,"background",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingBackground);
+      } else if (strncasecmp(encStr,"tight",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight);
+	requestLastRectEncoding = True;
+	if (appData.compressLevel >= 0 && appData.compressLevel <= 9)
+	  requestCompressLevel = True;
+	if (appData.qualityLevel >= 0 && appData.qualityLevel <= 9)
+	  requestQualityLevel = True;
+      } else if (strncasecmp(encStr,"hextile",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile);
+      } else if (strncasecmp(encStr,"zlib",encStrLen) == 0) {
+	encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib);
+	if (appData.compressLevel >= 0 && appData.compressLevel <= 9)
+	  requestCompressLevel = True;
+      } else {
+	fprintf(stderr,"Unknown encoding '%.*s'\n",encStrLen,encStr);
+      }
+
+      encStr = nextEncStr;
+    } while (encStr && se->nEncodings < MAX_ENCODINGS);
+
+    if (se->nEncodings < MAX_ENCODINGS && requestCompressLevel) {
+      encs[se->nEncodings++] = Swap32IfLE(appData.compressLevel +
+					  rfbEncodingCompressLevel0);
+    }
+
+    if (se->nEncodings < MAX_ENCODINGS && requestQualityLevel) {
+      encs[se->nEncodings++] = Swap32IfLE(appData.qualityLevel +
+					  rfbEncodingQualityLevel0);
+    }
+
+    if (se->nEncodings < MAX_ENCODINGS && requestLastRectEncoding) {
+      encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect);
+    }
+  }
+  else {
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect);
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight);
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile);
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib);
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw);
+
+    if (appData.compressLevel >= 0 && appData.compressLevel <= 9) {
+      encs[se->nEncodings++] = Swap32IfLE(appData.compressLevel +
+					  rfbEncodingCompressLevel0);
+    } 
+
+    if (appData.qualityLevel >= 0 && appData.qualityLevel <= 9) {
+      encs[se->nEncodings++] = Swap32IfLE(appData.qualityLevel +
+					  rfbEncodingQualityLevel0);
+    }
+
+    if (si.format.depth >= 8) 
+      encs[se->nEncodings++] = Swap32IfLE(rfbEncodingSoftCursor);
+    encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect);
+  }
+
+  len = sz_rfbSetEncodingsMsg + se->nEncodings * 4;
+
+  se->nEncodings = Swap16IfLE(se->nEncodings);
+
+  if (!WriteExact(rfbsock, buf, len)) return False;
+
+  return True;
+}
+
+
+/*
+ * SendIncrementalFramebufferUpdateRequest.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+SendIncrementalFramebufferUpdateRequest()
+{
+  return SendFramebufferUpdateRequest(0, 0, si.framebufferWidth,
+				      si.framebufferHeight, True);
+}
+
+
+/*
+ * SendFramebufferUpdateRequest.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+SendFramebufferUpdateRequest(int x, int y, int w, int h, Bool incremental)
+{
+  rfbFramebufferUpdateRequestMsg fur;
+
+  fur.type = rfbFramebufferUpdateRequest;
+  fur.incremental = incremental ? 1 : 0;
+  fur.x = Swap16IfLE(x);
+  fur.y = Swap16IfLE(y);
+  fur.w = Swap16IfLE(w);
+  fur.h = Swap16IfLE(h);
+
+  if (!WriteExact(rfbsock, (char *)&fur, sz_rfbFramebufferUpdateRequestMsg))
+    return False;
+
+  return True;
+}
+
+
+/*
+ * SendPointerEvent.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+SendPointerEvent(int x, int y, int buttonMask)
+{
+  rfbPointerEventMsg pe;
+
+  pe.type = rfbPointerEvent;
+  pe.buttonMask = buttonMask;
+  if (x < 0) x = 0;
+  if (y < 0) y = 0;
+  pe.x = Swap16IfLE(x);
+  pe.y = Swap16IfLE(y);
+  return WriteExact(rfbsock, (char *)&pe, sz_rfbPointerEventMsg);
+}
+
+
+/*
+ * SendKeyEvent.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+SendKeyEvent(CARD32 key, Bool down)
+{
+  rfbKeyEventMsg ke;
+
+  ke.type = rfbKeyEvent;
+  ke.down = down ? 1 : 0;
+  ke.key = Swap32IfLE(key);
+  return WriteExact(rfbsock, (char *)&ke, sz_rfbKeyEventMsg);
+}
+
+
+/*
+ * SendClientCutText.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+SendClientCutText(const char *str, int len)
+{
+  rfbClientCutTextMsg cct;
+
+  cct.type = rfbClientCutText;
+  cct.length = Swap32IfLE((unsigned int)len);
+  return  (WriteExact(rfbsock, (char *)&cct, sz_rfbClientCutTextMsg) &&
+	   WriteExact(rfbsock, str, len));
+}
+
+
+static Bool
+HandleSoftCursorSetImage(rfbSoftCursorSetImage *msg, rfbRectangle *rect) 
+{
+  int iindex = msg->imageIndex - rfbSoftCursorSetIconOffset;
+  PointerImage *pi = &pointerImages[iindex];
+  if (iindex >= rfbSoftCursorMaxImages) {
+    fprintf(stderr, "Received invalid soft cursor image index %d for SetImage\n", iindex);
+    return False;
+  }
+  EnableClientCursor(0);
+
+  if (pi->set && pi->image) 
+    free(pi->image);
+
+  pi->w = rect->w;
+  pi->h = rect->h;
+  pi->hotX = rect->x;
+  pi->hotY = rect->y;
+  pi->len = Swap16IfLE(msg->imageLength);
+  pi->image = malloc(pi->len);
+  if (!pi->image) {
+    fprintf(stderr, "out of memory (size=%d)\n", pi->len);
+    return False;
+  }
+
+  if (!ReadFromRFBServer(pi->image, pi->len)) 
+    return False;
+  pi->set = 1;
+  return True;
+}
+
+/* framebuffer must be locked when calling this!!! */
+static Bool
+PointerMove(unsigned int x, unsigned int y, unsigned int mask,
+	    int ox, int oy, int ow, int oh) 
+{
+  int nx, ny, nw, nh;
+
+  if (x >= si.framebufferWidth)
+    x = si.framebufferWidth - 1;
+  if (y >= si.framebufferHeight)
+    y = si.framebufferHeight - 1;
+
+  cursorX = x;
+  cursorY = y;
+  drawCursor();
+  UnlockFramebuffer();
+
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&nx, &ny, &nw, &nh);
+
+  if (rectsIntersect(ox, oy, ow, oh, nx, ny, nw, nh)) {
+    rectsJoin(&ox, &oy, &ow, &oh, nx, ny, nw, nh);
+    SyncScreenRegion(ox, oy, ow, oh);
+  }
+  else {
+    SyncScreenRegion(ox, oy, ow, oh);
+    SyncScreenRegion(nx, ny, nw, nh);
+  }
+
+  postMouseEvent(cursorX, cursorY, mask);
+
+  return True;
+}
+
+static Bool
+HandleSoftCursorMove(rfbSoftCursorMove *msg, rfbRectangle *rect) 
+{
+  int ii, ox, oy, ow, oh;
+
+  /* get old cursor rect to know what to update */
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&ox, &oy, &ow, &oh);
+
+  ii = msg->imageIndex;
+  if (ii >= rfbSoftCursorMaxImages) {
+    fprintf(stderr, "Received invalid soft cursor image index %d for Move\n", ii);
+    return False;
+  }
+
+  if (!pointerImages[ii].set)
+    return True;
+
+  LockFramebuffer();
+  undrawCursor();
+  imageIndex = ii;
+
+  return PointerMove(rect->w, rect->h, msg->buttonMask, ox, oy, ow, oh);
+}
+
+static Bool
+HandleCursorPos(unsigned int x, unsigned int y) 
+{
+  int ox, oy, ow, oh;
+
+  /* get old cursor rect to know what to update */
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&ox, &oy, &ow, &oh);
+  if (!pointerImages[0].set)
+    return True;
+
+  LockFramebuffer();
+  undrawCursor();
+  imageIndex = 0;
+  return PointerMove(x, y, 0, ox, oy, ow, oh);
+}
+
+/* call only from X11 thread. Only updates framebuffer, does not sync! */
+void DrawCursorX11Thread(int x, int y) {
+  int ox, oy, ow, oh, nx, ny, nw, nh;
+  if (!pointerImages[0].set)
+    return True;
+  imageIndex = 0;
+
+  if (x >= si.framebufferWidth)
+    x = si.framebufferWidth - 1;
+  if (y >= si.framebufferHeight)
+    y = si.framebufferHeight - 1;
+
+  LockFramebuffer();
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&ox, &oy, &ow, &oh);
+  undrawCursor();
+  cursorX = x;
+  cursorY = y;
+  drawCursor();
+  UnlockFramebuffer();
+
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&nx, &ny, &nw, &nh);
+  if (rectsIntersect(ox, oy, ow, oh, nx, ny, nw, nh)) {
+    rectsJoin(&ox, &oy, &ow, &oh, nx, ny, nw, nh);
+    SyncScreenRegionX11Thread(ox, oy, ow, oh);
+  }
+  else {
+    SyncScreenRegionX11Thread(ox, oy, ow, oh);
+    SyncScreenRegionX11Thread(nx, ny, nw, nh);
+  }
+}
+
+/**
+ * Create a softcursor in the "compressed alpha" format.
+ * Returns the softcursor, caller owns the object
+ */
+static void *MakeSoftCursor(int bpp, int cursorWidth, int cursorHeight, 
+			    CARD8 *cursorData, CARD8 *cursorMask, short *imageLen)
+{
+    int w = (cursorWidth+7)/8;
+    unsigned char *cp, *sp, *dstData;
+    int state; /* 0 = transparent, 1 otherwise */
+    CARD8 *counter;
+    unsigned char bit;
+    int i,j;
+    
+    sp = (unsigned char*)cursorData;
+    dstData = cp = (unsigned char*)calloc(cursorWidth*(bpp+2),cursorHeight);
+    if (!dstData)
+      return 0;
+
+    state = 0;
+    counter = cp++;
+    *counter = 0;
+    
+    for(j=0;j<cursorHeight;j++)
+	for(i=0,bit=0x80;i<cursorWidth;i++,bit=(bit&1)?0x80:bit>>1)
+	    if(cursorMask[j*w+i/8]&bit) {
+		if (state) {
+		    memcpy(cp,sp,bpp);
+		    cp += bpp;
+		    sp += bpp;
+		    (*counter)++;
+		    if (*counter == 255) {
+			state = 0;
+			counter = cp++;
+			*counter = 0;
+		    }
+		}
+		else {
+		    state = 1;
+		    counter = cp++;
+		    *counter = 1;
+		    memcpy(cp,sp,bpp);
+		    cp += bpp;
+		    sp += bpp;
+		}
+	    }
+	    else {
+		if (!state) {
+		    (*counter)++;
+		    if (*counter == 255) {
+			state = 1;
+			counter = cp++;
+			*counter = 0;
+		    }
+		}
+		else {
+		    state = 0;
+		    counter = cp++;
+		    *counter = 1;
+		}
+		sp += bpp;
+	    }
+
+    *imageLen = cp - dstData;
+    return (void*) dstData;
+}
+
+
+/*********************************************************************
+ * HandleCursorShape(). Support for XCursor and RichCursor shape
+ * updates. We emulate cursor operating on the frame buffer (that is
+ * why we call it "software cursor").
+ ********************************************************************/
+
+static Bool HandleCursorShape(int xhot, int yhot, int width, int height, CARD32 enc)
+{
+  int bytesPerPixel;
+  size_t bytesPerRow, bytesMaskData;
+  rfbXCursorColors rgb;
+  CARD32 colors[2];
+  CARD8 *ptr, *rcSource, *rcMask;
+  void *softCursor;
+  int x, y, b;
+  int ox, oy, ow, oh;
+  PointerImage *pi;
+  short imageLen;
+
+  bytesPerPixel = myFormat.bitsPerPixel / 8;
+  bytesPerRow = (width + 7) / 8;
+  bytesMaskData = bytesPerRow * height;
+
+  if (width * height == 0)
+    return True;
+
+  /* Allocate memory for pixel data and temporary mask data. */
+
+  rcSource = malloc(width * height * bytesPerPixel);
+  if (rcSource == NULL)
+    return False;
+
+  rcMask = malloc(bytesMaskData);
+  if (rcMask == NULL) {
+    free(rcSource);
+    return False;
+  }
+
+  /* Read and decode cursor pixel data, depending on the encoding type. */
+
+  if (enc == rfbEncodingXCursor) {
+    /* Read and convert background and foreground colors. */
+    if (!ReadFromRFBServer((char *)&rgb, sz_rfbXCursorColors)) {
+      free(rcSource);
+      free(rcMask);
+      return False;
+    }
+    colors[0] = RGB24_TO_PIXEL(32, rgb.backRed, rgb.backGreen, rgb.backBlue);
+    colors[1] = RGB24_TO_PIXEL(32, rgb.foreRed, rgb.foreGreen, rgb.foreBlue);
+
+    /* Read 1bpp pixel data into a temporary buffer. */
+    if (!ReadFromRFBServer((char*)rcMask, bytesMaskData)) {
+      free(rcSource);
+      free(rcMask);
+      return False;
+    }
+
+    /* Convert 1bpp data to byte-wide color indices. */
+    ptr = rcSource;
+    for (y = 0; y < height; y++) {
+      for (x = 0; x < width / 8; x++) {
+	for (b = 7; b >= 0; b--) {
+	  *ptr = rcMask[y * bytesPerRow + x] >> b & 1;
+	  ptr += bytesPerPixel;
+	}
+      }
+      for (b = 7; b > 7 - width % 8; b--) {
+	*ptr = rcMask[y * bytesPerRow + x] >> b & 1;
+	ptr += bytesPerPixel;
+      }
+    }
+
+    /* Convert indices into the actual pixel values. */
+    switch (bytesPerPixel) {
+    case 1:
+      for (x = 0; x < width * height; x++)
+	rcSource[x] = (CARD8)colors[rcSource[x]];
+      break;
+    case 2:
+      for (x = 0; x < width * height; x++)
+	((CARD16 *)rcSource)[x] = (CARD16)colors[rcSource[x * 2]];
+      break;
+    case 4:
+      for (x = 0; x < width * height; x++)
+	((CARD32 *)rcSource)[x] = colors[rcSource[x * 4]];
+      break;
+    }
+    
+
+  } else {
+    if (!ReadFromRFBServer((char *)rcSource, width * height * bytesPerPixel)) {
+      free(rcSource);
+      free(rcMask);
+      return False;
+    }
+  }
+
+  /* Read mask data. */
+
+  if (!ReadFromRFBServer((char*)rcMask, bytesMaskData)) {
+    free(rcSource);
+    free(rcMask);
+    return False;
+  }
+
+
+  /* Set the soft cursor. */
+  softCursor = MakeSoftCursor(bytesPerPixel, width, height, rcSource, rcMask, &imageLen);
+  if (!softCursor) {
+    free(rcMask);
+    free(rcSource);
+    return False;
+  }
+
+  /* get old cursor rect to know what to update */
+  EnableClientCursor(1);
+  LockFramebuffer();
+  getBoundingRectCursor(cursorX, cursorY, imageIndex,
+			&ox, &oy, &ow, &oh);
+  undrawCursor();
+
+  pi = &pointerImages[0];
+  if (pi->set && pi->image)
+    free(pi->image);
+  pi->w = width;
+  pi->h = height;
+  pi->hotX = xhot;
+  pi->hotY = yhot;
+  pi->len = imageLen;
+  pi->image = softCursor;
+  pi->set = 1;
+
+  imageIndex = 0;
+
+  free(rcMask);
+  free(rcSource);
+
+  return PointerMove(cursorX, cursorY, 0, ox, oy, ow, oh);
+}
+
+
+
+/*
+ * HandleRFBServerMessage.
+ */
+
+Bool
+HandleRFBServerMessage()
+{
+  rfbServerToClientMsg msg;
+  if (!ReadFromRFBServer((char *)&msg, 1))
+    return False;
+
+  switch (msg.type) {
+
+  case rfbSetColourMapEntries:
+  {
+    int i;
+    CARD16 rgb[3];
+    XColor xc;
+
+    if (!ReadFromRFBServer(((char *)&msg) + 1,
+			   sz_rfbSetColourMapEntriesMsg - 1))
+      return False;
+
+    msg.scme.firstColour = Swap16IfLE(msg.scme.firstColour);
+    msg.scme.nColours = Swap16IfLE(msg.scme.nColours);
+
+    for (i = 0; i < msg.scme.nColours; i++) {
+      if (!ReadFromRFBServer((char *)rgb, 6))
+	return False;
+      xc.pixel = msg.scme.firstColour + i;
+      xc.red = Swap16IfLE(rgb[0]);
+      xc.green = Swap16IfLE(rgb[1]);
+      xc.blue = Swap16IfLE(rgb[2]);
+      xc.flags = DoRed|DoGreen|DoBlue;
+      /* Disable colormaps
+      lockQt();
+      XStoreColor(dpy, cmap, &xc);
+      unlockQt();
+      */
+    }
+
+    break;
+  }
+
+  case rfbFramebufferUpdate:
+  {
+    rfbFramebufferUpdateRectHeader rect;
+    int linesToRead;
+    int bytesPerLine;
+    int i;
+
+    announceIncrementalUpdateRequest();
+
+    if (!ReadFromRFBServer(((char *)&msg.fu) + 1,
+			   sz_rfbFramebufferUpdateMsg - 1))
+      return False;
+
+    msg.fu.nRects = Swap16IfLE(msg.fu.nRects);
+
+    for (i = 0; i < msg.fu.nRects; i++) {
+      if (!ReadFromRFBServer((char *)&rect, sz_rfbFramebufferUpdateRectHeader))
+	return False;
+
+      rect.encoding = Swap32IfLE(rect.encoding);
+      if (rect.encoding == rfbEncodingLastRect)
+	break;
+
+      rect.r.x = Swap16IfLE(rect.r.x);
+      rect.r.y = Swap16IfLE(rect.r.y);
+      rect.r.w = Swap16IfLE(rect.r.w);
+      rect.r.h = Swap16IfLE(rect.r.h);
+
+      if (rect.encoding == rfbEncodingPointerPos) {
+        if (!HandleCursorPos(rect.r.x, rect.r.y)) {
+          return False;
+        }
+        continue;
+      }
+
+      if (rect.encoding == rfbEncodingXCursor ||
+	  rect.encoding == rfbEncodingRichCursor) {
+	if (!HandleCursorShape(rect.r.x, rect.r.y, rect.r.w, rect.r.h,
+			      rect.encoding)) {
+	  return False;
+	}
+	continue;
+      }
+
+      if ((rect.r.x + rect.r.w > si.framebufferWidth) ||
+	  (rect.r.y + rect.r.h > si.framebufferHeight))
+	{
+	  fprintf(stderr,"Rect too large: %dx%d at (%d, %d)\n",
+		  rect.r.w, rect.r.h, rect.r.x, rect.r.y);
+	  return False;
+	}
+
+      if ((rect.r.h * rect.r.w == 0) && 
+	  (rect.encoding != rfbEncodingSoftCursor)) {
+	fprintf(stderr,"Zero size rect - ignoring\n");
+	continue;
+      }
+
+      switch (rect.encoding) {
+
+      case rfbEncodingRaw:
+
+	bytesPerLine = rect.r.w * myFormat.bitsPerPixel / 8;
+	linesToRead = BUFFER_SIZE / bytesPerLine;
+
+	while (rect.r.h > 0) {
+	  if (linesToRead > rect.r.h)
+	    linesToRead = rect.r.h;
+
+	  if (!ReadFromRFBServer(buffer,bytesPerLine * linesToRead))
+	    return False;
+
+	  CopyDataToScreen(buffer, rect.r.x, rect.r.y, rect.r.w,
+			   linesToRead);
+
+	  rect.r.h -= linesToRead;
+	  rect.r.y += linesToRead;
+
+	}
+	break;
+
+      case rfbEncodingCopyRect:
+      {
+	rfbCopyRect cr;
+
+	if (!ReadFromRFBServer((char *)&cr, sz_rfbCopyRect))
+	  return False;
+
+	cr.srcX = Swap16IfLE(cr.srcX);
+	cr.srcY = Swap16IfLE(cr.srcY);
+
+	CopyArea(cr.srcX, cr.srcY, rect.r.w, rect.r.h, rect.r.x, rect.r.y);
+
+	break;
+      }
+
+      case rfbEncodingHextile:
+      {
+	switch (myFormat.bitsPerPixel) {
+	case 8:
+	  if (!HandleHextile8(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 16:
+	  if (!HandleHextile16(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 32:
+	  if (!HandleHextile32(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	}
+	break;
+      }
+
+      case rfbEncodingZlib:
+      {
+	switch (myFormat.bitsPerPixel) {
+	case 8:
+	  if (!HandleZlib8(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 16:
+	  if (!HandleZlib16(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 32:
+	  if (!HandleZlib32(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	}
+	break;
+     }
+
+      case rfbEncodingTight:
+      {
+	switch (myFormat.bitsPerPixel) {
+	case 8:
+	  if (!HandleTight8(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 16:
+	  if (!HandleTight16(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	case 32:
+	  if (!HandleTight32(rect.r.x,rect.r.y,rect.r.w,rect.r.h))
+	    return False;
+	  break;
+	}
+	break;
+      }
+
+      case rfbEncodingSoftCursor:
+      {
+	rfbSoftCursorMsg scmsg;
+	if (!ReadFromRFBServer((char *)&scmsg, 1))
+	  return False;
+	if (scmsg.type < rfbSoftCursorMaxImages) {
+	  if (!ReadFromRFBServer(((char *)&scmsg)+1, 
+				 sizeof(rfbSoftCursorMove)- 1))
+	    return False;
+	  if (!HandleSoftCursorMove(&scmsg.move, &rect.r))
+	    return False;
+	}
+	else if((scmsg.type >= rfbSoftCursorSetIconOffset) && 
+		(scmsg.type < rfbSoftCursorSetIconOffset+rfbSoftCursorMaxImages)) {
+	  if (!ReadFromRFBServer(((char *)&scmsg)+1, 
+				 sizeof(rfbSoftCursorSetImage)- 1))
+	    return False;
+	  if (!HandleSoftCursorSetImage(&scmsg.setImage, &rect.r))
+	    return False;
+	}
+	else {
+	  fprintf(stderr,"Unknown soft cursor image index %d\n", 
+		  (int)scmsg.type);
+	  return False;
+	}
+	break;
+      }
+
+      default:
+	fprintf(stderr,"Unknown rect encoding %d\n",
+		(int)rect.encoding);
+	return False;
+      }
+
+    }
+
+    queueIncrementalUpdateRequest();
+
+    break;
+  }
+
+  case rfbBell:
+  {
+    beep();
+    break;
+  }
+
+  case rfbServerCutText:
+  {
+    char *serverCutText;
+    if (!ReadFromRFBServer(((char *)&msg) + 1,
+			   sz_rfbServerCutTextMsg - 1))
+      return False;
+
+    msg.sct.length = Swap32IfLE(msg.sct.length);
+
+    if (msg.sct.length > MAX_CUTBUFFER) {
+      fprintf(stderr, "Cutbuffer too long.\n");
+      return False;
+    }
+
+    serverCutText = malloc(msg.sct.length+1);
+
+    if (!serverCutText) {
+      fprintf(stderr, "Out-of-memory, cutbuffer too long.\n");
+      return False;
+    }
+
+    if (!ReadFromRFBServer(serverCutText, msg.sct.length))
+      return False;
+
+    serverCutText[msg.sct.length] = 0;
+    newServerCut(serverCutText, msg.sct.length); /* takes ownership of serverCutText */
+
+    break;
+  }
+
+  default:
+    fprintf(stderr,"Unknown message type %d from VNC server\n",msg.type);
+    return False;
+  }
+
+  return True;
+}
+
+
+#define GET_PIXEL8(pix, ptr) ((pix) = *(ptr)++)
+
+#define GET_PIXEL16(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \
+			       ((CARD8*)&(pix))[1] = *(ptr)++)
+
+#define GET_PIXEL32(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \
+			       ((CARD8*)&(pix))[1] = *(ptr)++, \
+			       ((CARD8*)&(pix))[2] = *(ptr)++, \
+			       ((CARD8*)&(pix))[3] = *(ptr)++)
+
+/* CONCAT2 concatenates its two arguments.  CONCAT2E does the same but also
+   expands its arguments if they are macros */
+
+#define CONCAT2(a,b) a##b
+#define CONCAT2E(a,b) CONCAT2(a,b)
+
+#define BPP 8
+#include "hextile.c"
+#include "zlib.c"
+#include "tight.c"
+#undef BPP
+#define BPP 16
+#include "hextile.c"
+#include "zlib.c"
+#include "tight.c"
+#undef BPP
+#define BPP 32
+#include "hextile.c"
+#include "zlib.c"
+#include "tight.c"
+#undef BPP
+
+
+/*
+ * PrintPixelFormat.
+ */
+
+void
+PrintPixelFormat(format)
+    rfbPixelFormat *format;
+{
+  if (format->bitsPerPixel == 1) {
+    fprintf(stderr,"  Single bit per pixel.\n");
+    fprintf(stderr,
+	    "  %s significant bit in each byte is leftmost on the screen.\n",
+	    (format->bigEndian ? "Most" : "Least"));
+  } else {
+    fprintf(stderr,"  %d bits per pixel.\n",format->bitsPerPixel);
+    if (format->bitsPerPixel != 8) {
+      fprintf(stderr,"  %s significant byte first in each pixel.\n",
+	      (format->bigEndian ? "Most" : "Least"));
+    }
+    if (format->trueColour) {
+      fprintf(stderr,"  True colour: max red %d green %d blue %d",
+	      format->redMax, format->greenMax, format->blueMax);
+      fprintf(stderr,", shift red %d green %d blue %d\n",
+	      format->redShift, format->greenShift, format->blueShift);
+    } else {
+      fprintf(stderr,"  Colour map (not true colour).\n");
+    }
+  }
+}
+
+static long
+ReadCompactLen (void)
+{
+  long len;
+  CARD8 b;
+
+  if (!ReadFromRFBServer((char *)&b, 1))
+    return -1;
+  len = (int)b & 0x7F;
+  if (b & 0x80) {
+    if (!ReadFromRFBServer((char *)&b, 1))
+      return -1;
+    len |= ((int)b & 0x7F) << 7;
+    if (b & 0x80) {
+      if (!ReadFromRFBServer((char *)&b, 1))
+	return -1;
+      len |= ((int)b & 0xFF) << 14;
+    }
+  }
+  return len;
+}
+
+void freeRFBProtoResources() {
+  int i;
+
+  if (desktopName)
+    free(desktopName);
+  if (raw_buffer)
+    free(raw_buffer);
+  for (i = 0; i < rfbSoftCursorMaxImages; i++) 
+    if (pointerImages[i].set && pointerImages[i].image)
+      free(pointerImages[i].image);
+
+  raw_buffer_size = -1;
+  raw_buffer = NULL;
+  decompStreamInited = False;
+  zlibStreamActive[0] = False;
+  zlibStreamActive[1] = False;
+  zlibStreamActive[2] = False;
+  zlibStreamActive[3] = False;
+  for (i = 0; i < rfbSoftCursorMaxImages; i++) 
+    pointerImages[i].set = 0;
+  imageIndex = -1;
+}
+
+void freeResources() {
+  freeSocketsResources();
+  freeDesktopResources();
+  freeRFBProtoResources();
+}
+
+/*
+ * JPEG source manager functions for JPEG decompression in Tight decoder.
+ */
+
+static struct jpeg_source_mgr jpegSrcManager;
+static JOCTET *jpegBufferPtr;
+static size_t jpegBufferLen;
+
+static void
+JpegInitSource(j_decompress_ptr cinfo)
+{
+  jpegError = False;
+}
+
+static boolean
+JpegFillInputBuffer(j_decompress_ptr cinfo)
+{
+  jpegError = True;
+  jpegSrcManager.bytes_in_buffer = jpegBufferLen;
+  jpegSrcManager.next_input_byte = (JOCTET *)jpegBufferPtr;
+
+  return TRUE;
+}
+
+static void
+JpegSkipInputData(j_decompress_ptr cinfo, long num_bytes)
+{
+  if (num_bytes < 0 || num_bytes > jpegSrcManager.bytes_in_buffer) {
+    jpegError = True;
+    jpegSrcManager.bytes_in_buffer = jpegBufferLen;
+    jpegSrcManager.next_input_byte = (JOCTET *)jpegBufferPtr;
+  } else {
+    jpegSrcManager.next_input_byte += (size_t) num_bytes;
+    jpegSrcManager.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+static void
+JpegTermSource(j_decompress_ptr cinfo)
+{
+  /* No work necessary here. */
+}
+
+static void
+JpegSetSrcManager(j_decompress_ptr cinfo, CARD8 *compressedData,
+		  int compressedLen)
+{
+  jpegBufferPtr = (JOCTET *)compressedData;
+  jpegBufferLen = (size_t)compressedLen;
+
+  jpegSrcManager.init_source = JpegInitSource;
+  jpegSrcManager.fill_input_buffer = JpegFillInputBuffer;
+  jpegSrcManager.skip_input_data = JpegSkipInputData;
+  jpegSrcManager.resync_to_restart = jpeg_resync_to_restart;
+  jpegSrcManager.term_source = JpegTermSource;
+  jpegSrcManager.next_input_byte = jpegBufferPtr;
+  jpegSrcManager.bytes_in_buffer = jpegBufferLen;
+
+  cinfo->src = &jpegSrcManager;
+}
+
diff --git a/krdc/vnc/rfbproto.h b/krdc/vnc/rfbproto.h
new file mode 100644
index 00000000..61ceb903
--- /dev/null
+++ b/krdc/vnc/rfbproto.h
@@ -0,0 +1,957 @@
+/*
+ *  Copyright (C) 2000-2002 Constantin Kaplinsky.  All Rights Reserved.
+ *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * rfbproto.h - header file for the RFB protocol version 3.3
+ *
+ * Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed
+ * integer (for n = 8, 16 and 32).
+ *
+ * All multiple byte integers are in big endian (network) order (most
+ * significant byte first).  Unless noted otherwise there is no special
+ * alignment of protocol structures.
+ *
+ *
+ * Once the initial handshaking is done, all messages start with a type byte,
+ * (usually) followed by message-specific data.  The order of definitions in
+ * this file is as follows:
+ *
+ *  (1) Structures used in several types of message.
+ *  (2) Structures used in the initial handshaking.
+ *  (3) Message types.
+ *  (4) Encoding types.
+ *  (5) For each message type, the form of the data following the type byte.
+ *      Sometimes this is defined by a single structure but the more complex
+ *      messages have to be explained by comments.
+ */
+
+#include "vnctypes.h"
+
+/*****************************************************************************
+ *
+ * Structures used in several messages
+ *
+ *****************************************************************************/
+
+/*-----------------------------------------------------------------------------
+ * Structure used to specify a rectangle.  This structure is a multiple of 4
+ * bytes so that it can be interspersed with 32-bit pixel data without
+ * affecting alignment.
+ */
+
+typedef struct {
+    CARD16 x;
+    CARD16 y;
+    CARD16 w;
+    CARD16 h;
+} rfbRectangle;
+
+#define sz_rfbRectangle 8
+
+
+/*-----------------------------------------------------------------------------
+ * Structure used to specify pixel format.
+ */
+
+typedef struct {
+
+    CARD8 bitsPerPixel;		/* 8,16,32 only */
+
+    CARD8 depth;		/* 8 to 32 */
+
+    CARD8 bigEndian;		/* True if multi-byte pixels are interpreted
+				   as big endian, or if single-bit-per-pixel
+				   has most significant bit of the byte
+				   corresponding to first (leftmost) pixel. Of
+				   course this is meaningless for 8 bits/pix */
+
+    CARD8 trueColour;		/* If false then we need a "colour map" to
+				   convert pixels to RGB.  If true, xxxMax and
+				   xxxShift specify bits used for red, green
+				   and blue */
+
+    /* the following fields are only meaningful if trueColour is true */
+
+    CARD16 redMax;		/* maximum red value (= 2^n - 1 where n is the
+				   number of bits used for red). Note this
+				   value is always in big endian order. */
+
+    CARD16 greenMax;		/* similar for green */
+
+    CARD16 blueMax;		/* and blue */
+
+    CARD8 redShift;		/* number of shifts needed to get the red
+				   value in a pixel to the least significant
+				   bit. To find the red value from a given
+				   pixel, do the following:
+				   1) Swap pixel value according to bigEndian
+				      (e.g. if bigEndian is false and host byte
+				      order is big endian, then swap).
+				   2) Shift right by redShift.
+				   3) AND with redMax (in host byte order).
+				   4) You now have the red value between 0 and
+				      redMax. */
+
+    CARD8 greenShift;		/* similar for green */
+
+    CARD8 blueShift;		/* and blue */
+
+    CARD8 pad1;
+    CARD16 pad2;
+
+} rfbPixelFormat;
+
+#define sz_rfbPixelFormat 16
+
+
+
+/*****************************************************************************
+ *
+ * Initial handshaking messages
+ *
+ *****************************************************************************/
+
+/*-----------------------------------------------------------------------------
+ * Protocol Version
+ *
+ * The server always sends 12 bytes to start which identifies the latest RFB
+ * protocol version number which it supports.  These bytes are interpreted
+ * as a string of 12 ASCII characters in the format "RFB xxx.yyy\n" where
+ * xxx and yyy are the major and minor version numbers (for version 3.3
+ * this is "RFB 003.003\n").
+ *
+ * The client then replies with a similar 12-byte message giving the version
+ * number of the protocol which should actually be used (which may be different
+ * to that quoted by the server).
+ *
+ * It is intended that both clients and servers may provide some level of
+ * backwards compatibility by this mechanism.  Servers in particular should
+ * attempt to provide backwards compatibility, and even forwards compatibility
+ * to some extent.  For example if a client demands version 3.1 of the
+ * protocol, a 3.0 server can probably assume that by ignoring requests for
+ * encoding types it doesn't understand, everything will still work OK.  This
+ * will probably not be the case for changes in the major version number.
+ *
+ * The format string below can be used in sprintf or sscanf to generate or
+ * decode the version string respectively.
+ */
+
+#define rfbProtocolVersionFormat "RFB %03d.%03d\n"
+#define rfbProtocolMajorVersion 3
+#define rfbProtocolMinorVersion 3
+
+typedef char rfbProtocolVersionMsg[13];	/* allow extra byte for null */
+
+#define sz_rfbProtocolVersionMsg 12
+
+
+/*-----------------------------------------------------------------------------
+ * Authentication
+ *
+ * Once the protocol version has been decided, the server then sends a 32-bit
+ * word indicating whether any authentication is needed on the connection.
+ * The value of this word determines the authentication scheme in use.  For
+ * version 3.0 of the protocol this may have one of the following values:
+ */
+
+#define rfbConnFailed 0
+#define rfbNoAuth 1
+#define rfbVncAuth 2
+
+/*
+ * rfbConnFailed:	For some reason the connection failed (e.g. the server
+ *			cannot support the desired protocol version).  This is
+ *			followed by a string describing the reason (where a
+ *			string is specified as a 32-bit length followed by that
+ *			many ASCII characters).
+ *
+ * rfbNoAuth:		No authentication is needed.
+ *
+ * rfbVncAuth:		The VNC authentication scheme is to be used.  A 16-byte
+ *			challenge follows, which the client encrypts as
+ *			appropriate using the password and sends the resulting
+ *			16-byte response.  If the response is correct, the
+ *			server sends the 32-bit word rfbVncAuthOK.  If a simple
+ *			failure happens, the server sends rfbVncAuthFailed and
+ *			closes the connection. If the server decides that too
+ *			many failures have occurred, it sends rfbVncAuthTooMany
+ *			and closes the connection.  In the latter case, the
+ *			server should not allow an immediate reconnection by
+ *			the client.
+ */
+
+#define rfbVncAuthOK 0
+#define rfbVncAuthFailed 1
+#define rfbVncAuthTooMany 2
+
+
+/*-----------------------------------------------------------------------------
+ * Client Initialisation Message
+ *
+ * Once the client and server are sure that they're happy to talk to one
+ * another, the client sends an initialisation message.  At present this
+ * message only consists of a boolean indicating whether the server should try
+ * to share the desktop by leaving other clients connected, or give exclusive
+ * access to this client by disconnecting all other clients.
+ */
+
+typedef struct {
+    CARD8 shared;
+} rfbClientInitMsg;
+
+#define sz_rfbClientInitMsg 1
+
+
+/*-----------------------------------------------------------------------------
+ * Server Initialisation Message
+ *
+ * After the client initialisation message, the server sends one of its own.
+ * This tells the client the width and height of the server's framebuffer,
+ * its pixel format and the name associated with the desktop.
+ */
+
+typedef struct {
+    CARD16 framebufferWidth;
+    CARD16 framebufferHeight;
+    rfbPixelFormat format;	/* the server's preferred pixel format */
+    CARD32 nameLength;
+    /* followed by char name[nameLength] */
+} rfbServerInitMsg;
+
+#define sz_rfbServerInitMsg (8 + sz_rfbPixelFormat)
+
+
+/*
+ * Following the server initialisation message it's up to the client to send
+ * whichever protocol messages it wants.  Typically it will send a
+ * SetPixelFormat message and a SetEncodings message, followed by a
+ * FramebufferUpdateRequest.  From then on the server will send
+ * FramebufferUpdate messages in response to the client's
+ * FramebufferUpdateRequest messages.  The client should send
+ * FramebufferUpdateRequest messages with incremental set to true when it has
+ * finished processing one FramebufferUpdate and is ready to process another.
+ * With a fast client, the rate at which FramebufferUpdateRequests are sent
+ * should be regulated to avoid hogging the network.
+ */
+
+
+
+/*****************************************************************************
+ *
+ * Message types
+ *
+ *****************************************************************************/
+
+/* server -> client */
+
+#define rfbFramebufferUpdate 0
+#define rfbSetColourMapEntries 1
+#define rfbBell 2
+#define rfbServerCutText 3
+
+
+/* client -> server */
+
+#define rfbSetPixelFormat 0
+#define rfbFixColourMapEntries 1	/* not currently supported */
+#define rfbSetEncodings 2
+#define rfbFramebufferUpdateRequest 3
+#define rfbKeyEvent 4
+#define rfbPointerEvent 5
+#define rfbClientCutText 6
+
+
+
+
+/*****************************************************************************
+ *
+ * Encoding types
+ *
+ *****************************************************************************/
+
+#define rfbEncodingRaw 0
+#define rfbEncodingCopyRect 1
+#define rfbEncodingRRE 2
+#define rfbEncodingCoRRE 4
+#define rfbEncodingHextile 5
+#define rfbEncodingZlib 6
+#define rfbEncodingTight 7
+#define rfbEncodingZlibHex 8
+
+/*
+ * Special encoding numbers:
+ *   0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels;
+ *   0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data;
+ *   0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions;
+ *   0xFFFFFF30 .. 0xFFFFFFDF -- not allocated yet;
+ *   0xFFFFFFE0 .. 0xFFFFFFEF -- quality level for JPEG compressor;
+ *   0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels.
+ */
+
+#define rfbEncodingCompressLevel0  0xFFFFFF00
+#define rfbEncodingCompressLevel1  0xFFFFFF01
+#define rfbEncodingCompressLevel2  0xFFFFFF02
+#define rfbEncodingCompressLevel3  0xFFFFFF03
+#define rfbEncodingCompressLevel4  0xFFFFFF04
+#define rfbEncodingCompressLevel5  0xFFFFFF05
+#define rfbEncodingCompressLevel6  0xFFFFFF06
+#define rfbEncodingCompressLevel7  0xFFFFFF07
+#define rfbEncodingCompressLevel8  0xFFFFFF08
+#define rfbEncodingCompressLevel9  0xFFFFFF09
+
+#define rfbEncodingXCursor         0xFFFFFF10
+#define rfbEncodingRichCursor      0xFFFFFF11
+#define rfbEncodingSoftCursor      0xFFFFFF12
+#define rfbEncodingPointerPos      0xFFFFFF18
+
+#define rfbEncodingLastRect        0xFFFFFF20
+#define rfbEncodingBackground      0xFFFFFF25
+
+#define rfbEncodingQualityLevel0   0xFFFFFFE0
+#define rfbEncodingQualityLevel1   0xFFFFFFE1
+#define rfbEncodingQualityLevel2   0xFFFFFFE2
+#define rfbEncodingQualityLevel3   0xFFFFFFE3
+#define rfbEncodingQualityLevel4   0xFFFFFFE4
+#define rfbEncodingQualityLevel5   0xFFFFFFE5
+#define rfbEncodingQualityLevel6   0xFFFFFFE6
+#define rfbEncodingQualityLevel7   0xFFFFFFE7
+#define rfbEncodingQualityLevel8   0xFFFFFFE8
+#define rfbEncodingQualityLevel9   0xFFFFFFE9
+
+
+/*****************************************************************************
+ *
+ * Server -> client message definitions
+ *
+ *****************************************************************************/
+
+
+/*-----------------------------------------------------------------------------
+ * FramebufferUpdate - a block of rectangles to be copied to the framebuffer.
+ *
+ * This message consists of a header giving the number of rectangles of pixel
+ * data followed by the rectangles themselves.  The header is padded so that
+ * together with the type byte it is an exact multiple of 4 bytes (to help
+ * with alignment of 32-bit pixels):
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbFramebufferUpdate */
+    CARD8 pad;
+    CARD16 nRects;
+    /* followed by nRects rectangles */
+} rfbFramebufferUpdateMsg;
+
+#define sz_rfbFramebufferUpdateMsg 4
+
+/*
+ * Each rectangle of pixel data consists of a header describing the position
+ * and size of the rectangle and a type word describing the encoding of the
+ * pixel data, followed finally by the pixel data.  Note that if the client has
+ * not sent a SetEncodings message then it will only receive raw pixel data.
+ * Also note again that this structure is a multiple of 4 bytes.
+ */
+
+typedef struct {
+    rfbRectangle r;
+    CARD32 encoding;	/* one of the encoding types rfbEncoding... */
+} rfbFramebufferUpdateRectHeader;
+
+#define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4)
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Raw Encoding.  Pixels are sent in top-to-bottom scanline order,
+ * left-to-right within a scanline with no padding in between.
+ */
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * CopyRect Encoding.  The pixels are specified simply by the x and y position
+ * of the source rectangle.
+ */
+
+typedef struct {
+    CARD16 srcX;
+    CARD16 srcY;
+} rfbCopyRect;
+
+#define sz_rfbCopyRect 4
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * RRE - Rise-and-Run-length Encoding.  We have an rfbRREHeader structure
+ * giving the number of subrectangles following.  Finally the data follows in
+ * the form [<bgpixel><subrect><subrect>...] where each <subrect> is
+ * [<pixel><rfbRectangle>].
+ */
+
+typedef struct {
+    CARD32 nSubrects;
+} rfbRREHeader;
+
+#define sz_rfbRREHeader 4
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * CoRRE - Compact RRE Encoding.  We have an rfbRREHeader structure giving
+ * the number of subrectangles following.  Finally the data follows in the form
+ * [<bgpixel><subrect><subrect>...] where each <subrect> is
+ * [<pixel><rfbCoRRERectangle>].  This means that
+ * the whole rectangle must be at most 255x255 pixels.
+ */
+
+typedef struct {
+    CARD8 x;
+    CARD8 y;
+    CARD8 w;
+    CARD8 h;
+} rfbCoRRERectangle;
+
+#define sz_rfbCoRRERectangle 4
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Hextile Encoding.  The rectangle is divided up into "tiles" of 16x16 pixels,
+ * starting at the top left going in left-to-right, top-to-bottom order.  If
+ * the width of the rectangle is not an exact multiple of 16 then the width of
+ * the last tile in each row will be correspondingly smaller.  Similarly if the
+ * height is not an exact multiple of 16 then the height of each tile in the
+ * final row will also be smaller.  Each tile begins with a "subencoding" type
+ * byte, which is a mask made up of a number of bits.  If the Raw bit is set
+ * then the other bits are irrelevant; w*h pixel values follow (where w and h
+ * are the width and height of the tile).  Otherwise the tile is encoded in a
+ * similar way to RRE, except that the position and size of each subrectangle
+ * can be specified in just two bytes.  The other bits in the mask are as
+ * follows:
+ *
+ * BackgroundSpecified - if set, a pixel value follows which specifies
+ *    the background colour for this tile.  The first non-raw tile in a
+ *    rectangle must have this bit set.  If this bit isn't set then the
+ *    background is the same as the last tile.
+ *
+ * ForegroundSpecified - if set, a pixel value follows which specifies
+ *    the foreground colour to be used for all subrectangles in this tile.
+ *    If this bit is set then the SubrectsColoured bit must be zero.
+ *
+ * AnySubrects - if set, a single byte follows giving the number of
+ *    subrectangles following.  If not set, there are no subrectangles (i.e.
+ *    the whole tile is just solid background colour).
+ *
+ * SubrectsColoured - if set then each subrectangle is preceded by a pixel
+ *    value giving the colour of that subrectangle.  If not set, all
+ *    subrectangles are the same colour, the foreground colour;  if the
+ *    ForegroundSpecified bit wasn't set then the foreground is the same as
+ *    the last tile.
+ *
+ * The position and size of each subrectangle is specified in two bytes.  The
+ * Pack macros below can be used to generate the two bytes from x, y, w, h,
+ * and the Extract macros can be used to extract the x, y, w, h values from
+ * the two bytes.
+ */
+
+#define rfbHextileRaw			(1 << 0)
+#define rfbHextileBackgroundSpecified	(1 << 1)
+#define rfbHextileForegroundSpecified	(1 << 2)
+#define rfbHextileAnySubrects		(1 << 3)
+#define rfbHextileSubrectsColoured	(1 << 4)
+
+#define rfbHextilePackXY(x,y) (((x) << 4) | (y))
+#define rfbHextilePackWH(w,h) ((((w)-1) << 4) | ((h)-1))
+#define rfbHextileExtractX(byte) ((byte) >> 4)
+#define rfbHextileExtractY(byte) ((byte) & 0xf)
+#define rfbHextileExtractW(byte) (((byte) >> 4) + 1)
+#define rfbHextileExtractH(byte) (((byte) & 0xf) + 1)
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * zlib - zlib compressed Encoding.  We have an rfbZlibHeader structure
+ * giving the number of bytes following.  Finally the data follows is
+ * zlib compressed version of the raw pixel data as negotiated.
+ */
+
+typedef struct {
+    CARD32 nBytes;
+} rfbZlibHeader;
+
+#define sz_rfbZlibHeader 4
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Tight Encoding.
+ *
+ *-- The first byte of each Tight-encoded rectangle is a "compression control
+ *   byte". Its format is as follows (bit 0 is the least significant one):
+ *
+ *   bit 0:    if 1, then compression stream 0 should be reset;
+ *   bit 1:    if 1, then compression stream 1 should be reset;
+ *   bit 2:    if 1, then compression stream 2 should be reset;
+ *   bit 3:    if 1, then compression stream 3 should be reset;
+ *   bits 7-4: if 1000 (0x08), then the compression type is "fill",
+ *             if 1001 (0x09), then the compression type is "jpeg",
+ *             if 0xxx, then the compression type is "basic",
+ *             values greater than 1001 are not valid.
+ *
+ * If the compression type is "basic", then bits 6..4 of the
+ * compression control byte (those xxx in 0xxx) specify the following:
+ *
+ *   bits 5-4:  decimal representation is the index of a particular zlib
+ *              stream which should be used for decompressing the data;
+ *   bit 6:     if 1, then a "filter id" byte is following this byte.
+ *
+ *-- The data that follows after the compression control byte described
+ * above depends on the compression type ("fill", "jpeg" or "basic").
+ *
+ *-- If the compression type is "fill", then the only pixel value follows, in
+ * client pixel format (see NOTE 1). This value applies to all pixels of the
+ * rectangle.
+ *
+ *-- If the compression type is "jpeg", the following data stream looks like
+ * this:
+ *
+ *   1..3 bytes:  data size (N) in compact representation;
+ *   N bytes:     JPEG image.
+ *
+ * Data size is compactly represented in one, two or three bytes, according
+ * to the following scheme:
+ *
+ *  0xxxxxxx                    (for values 0..127)
+ *  1xxxxxxx 0yyyyyyy           (for values 128..16383)
+ *  1xxxxxxx 1yyyyyyy zzzzzzzz  (for values 16384..4194303)
+ *
+ * Here each character denotes one bit, xxxxxxx are the least significant 7
+ * bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the
+ * most significant 8 bits (bits 14-21). For example, decimal value 10000
+ * should be represented as two bytes: binary 10010000 01001110, or
+ * hexadecimal 90 4E.
+ *
+ *-- If the compression type is "basic" and bit 6 of the compression control
+ * byte was set to 1, then the next (second) byte specifies "filter id" which
+ * tells the decoder what filter type was used by the encoder to pre-process
+ * pixel data before the compression. The "filter id" byte can be one of the
+ * following:
+ *
+ *   0:  no filter ("copy" filter);
+ *   1:  "palette" filter;
+ *   2:  "gradient" filter.
+ *
+ *-- If bit 6 of the compression control byte is set to 0 (no "filter id"
+ * byte), or if the filter id is 0, then raw pixel values in the client
+ * format (see NOTE 1) will be compressed. See below details on the
+ * compression.
+ *
+ *-- The "gradient" filter pre-processes pixel data with a simple algorithm
+ * which converts each color component to a difference between a "predicted"
+ * intensity and the actual intensity. Such a technique does not affect
+ * uncompressed data size, but helps to compress photo-like images better. 
+ * Pseudo-code for converting intensities to differences is the following:
+ *
+ *   P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1];
+ *   if (P[i,j] < 0) then P[i,j] := 0;
+ *   if (P[i,j] > MAX) then P[i,j] := MAX;
+ *   D[i,j] := V[i,j] - P[i,j];
+ *
+ * Here V[i,j] is the intensity of a color component for a pixel at
+ * coordinates (i,j). MAX is the maximum value of intensity for a color
+ * component.
+ *
+ *-- The "palette" filter converts true-color pixel data to indexed colors
+ * and a palette which can consist of 2..256 colors. If the number of colors
+ * is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to
+ * encode one pixel. 1-bit encoding is performed such way that the most
+ * significant bits correspond to the leftmost pixels, and each raw of pixels
+ * is aligned to the byte boundary. When "palette" filter is used, the
+ * palette is sent before the pixel data. The palette begins with an unsigned
+ * byte which value is the number of colors in the palette minus 1 (i.e. 1
+ * means 2 colors, 255 means 256 colors in the palette). Then follows the
+ * palette itself which consist of pixel values in client pixel format (see
+ * NOTE 1).
+ *
+ *-- The pixel data is compressed using the zlib library. But if the data
+ * size after applying the filter but before the compression is less then 12,
+ * then the data is sent as is, uncompressed. Four separate zlib streams
+ * (0..3) can be used and the decoder should read the actual stream id from
+ * the compression control byte (see NOTE 2).
+ *
+ * If the compression is not used, then the pixel data is sent as is,
+ * otherwise the data stream looks like this:
+ *
+ *   1..3 bytes:  data size (N) in compact representation;
+ *   N bytes:     zlib-compressed data.
+ *
+ * Data size is compactly represented in one, two or three bytes, just like
+ * in the "jpeg" compression method (see above).
+ *
+ *-- NOTE 1. If the color depth is 24, and all three color components are
+ * 8-bit wide, then one pixel in Tight encoding is always represented by
+ * three bytes, where the first byte is red component, the second byte is
+ * green component, and the third byte is blue component of the pixel color
+ * value. This applies to colors in palettes as well.
+ *
+ *-- NOTE 2. The decoder must reset compression streams' states before
+ * decoding the rectangle, if some of bits 0,1,2,3 in the compression control
+ * byte are set to 1. Note that the decoder must reset zlib streams even if
+ * the compression type is "fill" or "jpeg".
+ *
+ *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only
+ * when bits-per-pixel value is either 16 or 32, not 8.
+ *
+ *-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048
+ * pixels. If a rectangle is wider, it must be split into several rectangles
+ * and each one should be encoded separately.
+ *
+ */
+
+#define rfbTightExplicitFilter         0x04
+#define rfbTightFill                   0x08
+#define rfbTightJpeg                   0x09
+#define rfbTightMaxSubencoding         0x09
+
+/* Filters to improve compression efficiency */
+#define rfbTightFilterCopy             0x00
+#define rfbTightFilterPalette          0x01
+#define rfbTightFilterGradient         0x02
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * XCursor encoding. This is a special encoding used to transmit X-style
+ * cursor shapes from server to clients. Note that for this encoding,
+ * coordinates in rfbFramebufferUpdateRectHeader structure hold hotspot
+ * position (r.x, r.y) and cursor size (r.w, r.h). If (w * h != 0), two RGB
+ * samples are sent after header in the rfbXCursorColors structure. They
+ * denote foreground and background colors of the cursor. If a client
+ * supports only black-and-white cursors, it should ignore these colors and
+ * assume that foreground is black and background is white. Next, two bitmaps
+ * (1 bits per pixel) follow: first one with actual data (value 0 denotes
+ * background color, value 1 denotes foreground color), second one with
+ * transparency data (bits with zero value mean that these pixels are
+ * transparent). Both bitmaps represent cursor data in a byte stream, from
+ * left to right, from top to bottom, and each row is byte-aligned. Most
+ * significant bits correspond to leftmost pixels. The number of bytes in
+ * each row can be calculated as ((w + 7) / 8). If (w * h == 0), cursor
+ * should be hidden (or default local cursor should be set by the client).
+ */
+
+typedef struct {
+    CARD8 foreRed;
+    CARD8 foreGreen;
+    CARD8 foreBlue;
+    CARD8 backRed;
+    CARD8 backGreen;
+    CARD8 backBlue;
+} rfbXCursorColors;
+
+#define sz_rfbXCursorColors 6
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * RichCursor encoding. This is a special encoding used to transmit cursor
+ * shapes from server to clients. It is similar to the XCursor encoding but
+ * uses client pixel format instead of two RGB colors to represent cursor
+ * image. For this encoding, coordinates in rfbFramebufferUpdateRectHeader
+ * structure hold hotspot position (r.x, r.y) and cursor size (r.w, r.h).
+ * After header, two pixmaps follow: first one with cursor image in current
+ * client pixel format (like in raw encoding), second with transparency data
+ * (1 bit per pixel, exactly the same format as used for transparency bitmap
+ * in the XCursor encoding). If (w * h == 0), cursor should be hidden (or
+ * default local cursor should be set by the client).
+ */
+
+
+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * SoftCursor encoding. This encoding is used to transmit image and position 
+ * of the remote cursor. It has two sub-messages: SetImage is used to upload
+ * one of 16 images, and Move selects the image and sets the position of the
+ * cursor. 
+ * Each SoftCursor message starts with a CARD8. If it is in the 0-15 range
+ * it specifies the number of the cursor image and is followed by the 
+ * rfbSoftCursorMove message. If the given cursor has not been set yet the 
+ * message will be ignored. If the first CARD8 is in the 128-143 range it 
+ * specifies the cursor that will be set in the following 
+ * rfbSoftCursorSetImage message. To hide the cursor send a SetImage
+ * message with width and height 0 and imageLength 0.
+ * SetImage transmits the hotspot coordinates in the x/y fields of the
+ * rfbFramebufferUpdateRectHeader, width and height of the image are in the
+ * header's width and height fields.
+ * Move transmits the pointer coordinates in the w/h fields of the
+ * header, x/y are always 0.
+ */
+
+typedef struct {
+  CARD8 imageIndex;
+  CARD8 buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */
+} rfbSoftCursorMove;
+
+typedef struct {
+  CARD8 imageIndex;
+  CARD8 padding;
+  CARD16 imageLength;
+  /* 
+   * Followed by an image of the cursor in the client's image format
+   * with the following RLE mask compression. It begins with CARD8 that
+   * specifies the number of mask'ed pixels that will be NOT transmitted.
+   * Then follows a CARD8 that specified by the number of unmask'd pixels 
+   * that will be transmitted next. Then a CARD8 with the number of mask'd 
+   * pixels and so on. 
+   */
+} rfbSoftCursorSetImage;
+
+typedef union {
+  CARD8 type;
+  rfbSoftCursorMove move;
+  rfbSoftCursorSetImage setImage;
+} rfbSoftCursorMsg;
+
+#define rfbSoftCursorMaxImages    16
+#define rfbSoftCursorSetIconOffset    128
+
+/*-----------------------------------------------------------------------------
+ * SetColourMapEntries - these messages are only sent if the pixel
+ * format uses a "colour map" (i.e. trueColour false) and the client has not
+ * fixed the entire colour map using FixColourMapEntries.  In addition they
+ * will only start being sent after the client has sent its first
+ * FramebufferUpdateRequest.  So if the client always tells the server to use
+ * trueColour then it never needs to process this type of message.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbSetColourMapEntries */
+    CARD8 pad;
+    CARD16 firstColour;
+    CARD16 nColours;
+
+    /* Followed by nColours * 3 * CARD16
+       r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */
+
+} rfbSetColourMapEntriesMsg;
+
+#define sz_rfbSetColourMapEntriesMsg 6
+
+
+
+/*-----------------------------------------------------------------------------
+ * Bell - ring a bell on the client if it has one.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbBell */
+} rfbBellMsg;
+
+#define sz_rfbBellMsg 1
+
+
+
+/*-----------------------------------------------------------------------------
+ * ServerCutText - the server has new text in its cut buffer.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbServerCutText */
+    CARD8 pad1;
+    CARD16 pad2;
+    CARD32 length;
+    /* followed by char text[length] */
+} rfbServerCutTextMsg;
+
+#define sz_rfbServerCutTextMsg 8
+
+
+/*-----------------------------------------------------------------------------
+ * Union of all server->client messages.
+ */
+
+typedef union {
+    CARD8 type;
+    rfbFramebufferUpdateMsg fu;
+    rfbSetColourMapEntriesMsg scme;
+    rfbBellMsg b;
+    rfbServerCutTextMsg sct;
+} rfbServerToClientMsg;
+
+
+
+/*****************************************************************************
+ *
+ * Message definitions (client -> server)
+ *
+ *****************************************************************************/
+
+
+/*-----------------------------------------------------------------------------
+ * SetPixelFormat - tell the RFB server the format in which the client wants
+ * pixels sent.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbSetPixelFormat */
+    CARD8 pad1;
+    CARD16 pad2;
+    rfbPixelFormat format;
+} rfbSetPixelFormatMsg;
+
+#define sz_rfbSetPixelFormatMsg (sz_rfbPixelFormat + 4)
+
+
+/*-----------------------------------------------------------------------------
+ * FixColourMapEntries - when the pixel format uses a "colour map", fix
+ * read-only colour map entries.
+ *
+ *    ***************** NOT CURRENTLY SUPPORTED *****************
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbFixColourMapEntries */
+    CARD8 pad;
+    CARD16 firstColour;
+    CARD16 nColours;
+
+    /* Followed by nColours * 3 * CARD16
+       r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */
+
+} rfbFixColourMapEntriesMsg;
+
+#define sz_rfbFixColourMapEntriesMsg 6
+
+
+/*-----------------------------------------------------------------------------
+ * SetEncodings - tell the RFB server which encoding types we accept.  Put them
+ * in order of preference, if we have any.  We may always receive raw
+ * encoding, even if we don't specify it here.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbSetEncodings */
+    CARD8 pad;
+    CARD16 nEncodings;
+    /* followed by nEncodings * CARD32 encoding types */
+} rfbSetEncodingsMsg;
+
+#define sz_rfbSetEncodingsMsg 4
+
+
+/*-----------------------------------------------------------------------------
+ * FramebufferUpdateRequest - request for a framebuffer update.  If incremental
+ * is true then the client just wants the changes since the last update.  If
+ * false then it wants the whole of the specified rectangle.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbFramebufferUpdateRequest */
+    CARD8 incremental;
+    CARD16 x;
+    CARD16 y;
+    CARD16 w;
+    CARD16 h;
+} rfbFramebufferUpdateRequestMsg;
+
+#define sz_rfbFramebufferUpdateRequestMsg 10
+
+
+/*-----------------------------------------------------------------------------
+ * KeyEvent - key press or release
+ *
+ * Keys are specified using the "keysym" values defined by the X Window System.
+ * For most ordinary keys, the keysym is the same as the corresponding ASCII
+ * value.  Other common keys are:
+ *
+ * BackSpace		0xff08
+ * Tab			0xff09
+ * Return or Enter	0xff0d
+ * Escape		0xff1b
+ * Insert		0xff63
+ * Delete		0xffff
+ * Home			0xff50
+ * End			0xff57
+ * Page Up		0xff55
+ * Page Down		0xff56
+ * Left			0xff51
+ * Up			0xff52
+ * Right		0xff53
+ * Down			0xff54
+ * F1			0xffbe
+ * F2			0xffbf
+ * ...			...
+ * F12			0xffc9
+ * Shift		0xffe1
+ * Control		0xffe3
+ * Meta			0xffe7
+ * Alt			0xffe9
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbKeyEvent */
+    CARD8 down;			/* true if down (press), false if up */
+    CARD16 pad;
+    CARD32 key;			/* key is specified as an X keysym */
+} rfbKeyEventMsg;
+
+#define sz_rfbKeyEventMsg 8
+
+
+/*-----------------------------------------------------------------------------
+ * PointerEvent - mouse/pen move and/or button press.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbPointerEvent */
+    CARD8 buttonMask;		/* bits 0-7 are buttons 1-8, 0=up, 1=down */
+    CARD16 x;
+    CARD16 y;
+} rfbPointerEventMsg;
+
+#define rfbButton1Mask 1
+#define rfbButton2Mask 2
+#define rfbButton3Mask 4
+
+#define sz_rfbPointerEventMsg 6
+
+
+
+/*-----------------------------------------------------------------------------
+ * ClientCutText - the client has new text in its cut buffer.
+ */
+
+typedef struct {
+    CARD8 type;			/* always rfbClientCutText */
+    CARD8 pad1;
+    CARD16 pad2;
+    CARD32 length;
+    /* followed by char text[length] */
+} rfbClientCutTextMsg;
+
+#define sz_rfbClientCutTextMsg 8
+
+
+
+/*-----------------------------------------------------------------------------
+ * Union of all client->server messages.
+ */
+
+typedef union {
+    CARD8 type;
+    rfbSetPixelFormatMsg spf;
+    rfbFixColourMapEntriesMsg fcme;
+    rfbSetEncodingsMsg se;
+    rfbFramebufferUpdateRequestMsg fur;
+    rfbKeyEventMsg ke;
+    rfbPointerEventMsg pe;
+    rfbClientCutTextMsg cct;
+} rfbClientToServerMsg;
diff --git a/krdc/vnc/sockets.c b/krdc/vnc/sockets.c
new file mode 100644
index 00000000..797dd22d
--- /dev/null
+++ b/krdc/vnc/sockets.c
@@ -0,0 +1,325 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ *
+ * 03-05-2002 tim@tjansen.de: removed Xt event processing for krdc
+ */
+
+/*
+ * sockets.c - functions to deal with sockets.
+ */
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <assert.h>
+#include "vncviewer.h"
+
+void PrintInHex(char *buf, int len);
+
+Bool errorMessageOnReadFailure = True;
+
+#define BUF_SIZE 8192
+static char buf[BUF_SIZE];
+static char *bufoutptr = buf;
+static unsigned int buffered = 0;
+
+/* Wait duration of select in seconds */
+#define SELECT_PERIOD 3
+
+
+/*
+ * ReadFromRFBServer is called whenever we want to read some data from the RFB
+ * server.  
+ */
+Bool
+ReadFromRFBServer(char *out, unsigned int n)
+{
+  fd_set fds;
+  int e;
+  struct timeval tx;
+
+  if (isQuitFlagSet())
+    return False;
+
+  if (n <= buffered) {
+    memcpy(out, bufoutptr, n);
+    bufoutptr += n;
+    buffered -= n;
+    return True;
+  }
+
+  memcpy(out, bufoutptr, buffered);
+
+  out += buffered;
+  n -= buffered;
+
+  bufoutptr = buf;
+  buffered = 0;
+
+  if (n <= BUF_SIZE) {
+
+    while (buffered < n) {
+      int i;
+      if (isQuitFlagSet())
+	return False;
+      i = read(rfbsock, buf + buffered, BUF_SIZE - buffered);
+
+      if (i <= 0) {
+	if (i < 0) {
+	  if (errno == EWOULDBLOCK || errno == EAGAIN) {
+	    FD_ZERO(&fds);
+	    FD_SET(rfbsock,&fds);
+
+	    tx.tv_sec = SELECT_PERIOD;
+	    tx.tv_usec = 0;
+	    if ((e=select(rfbsock+1, &fds, NULL, &fds, &tx)) < 0) {
+	      perror("krdc: select read");
+	      return False;
+	    }
+	    i = 0;
+	  } else {
+	    perror("krdc: read");
+	    return False;
+	  }
+	} else { 
+	  fprintf(stderr,"VNC server closed connection\n");
+	  return False;
+	}
+      }
+      buffered += i;
+    }
+
+    memcpy(out, bufoutptr, n);
+    bufoutptr += n;
+    buffered -= n;
+    return isQuitFlagSet() ? False : True;
+
+  } else {
+
+    while (n > 0) {
+      int i;
+      if (isQuitFlagSet())
+	return False;
+      i = read(rfbsock, out, n);
+      if (i <= 0) {
+	if (i < 0) {
+	  if (errno == EWOULDBLOCK || errno == EAGAIN) {
+	    FD_ZERO(&fds);
+	    FD_SET(rfbsock,&fds);
+
+	    tx.tv_sec = SELECT_PERIOD;
+	    tx.tv_usec = 0;
+	    if ((e=select(rfbsock+1, &fds, NULL, &fds, &tx)) < 0) {
+	      perror("krdc: select");
+	      return False;
+	    }	    
+	    i = 0;
+	  } else {
+	    perror("krdc: read");
+	    return False;
+	  }
+	} else { 
+	  fprintf(stderr,"VNC server closed connection\n");
+	  return False;
+	}
+      }
+      out += i;
+      n -= i;
+    }
+
+    return isQuitFlagSet() ? False : True;
+  }
+}
+
+
+/*
+ * Write an exact number of bytes, and don't return until you've sent them.
+ * Note: this should only be called by the WriterThread
+ */
+
+Bool
+WriteExact(int sock, const char *_buf, int n)
+{
+  fd_set fds;
+  int i = 0;
+  int j;
+  int e;
+  struct timeval tx;
+
+  while (i < n) {
+    if (isQuitFlagSet())
+      return False;
+    j = write(sock, _buf + i, (n - i));
+    if (j <= 0) {
+      if (j < 0) {
+	if (errno == EWOULDBLOCK || errno == EAGAIN) {
+	  FD_ZERO(&fds);
+	  FD_SET(rfbsock,&fds);
+
+	  tx.tv_sec = SELECT_PERIOD;
+	  tx.tv_usec = 0;
+	  if ((e=select(rfbsock+1, NULL, &fds, NULL, &tx)) < 0) {
+	    perror("krdc: select write");
+	    return False;
+	  }
+	  j = 0;
+	} else {
+	  perror("krdc: write");
+	  return False;
+	}
+      } else {
+	fprintf(stderr,"write failed\n");
+	return False;
+      }
+    }
+    i += j;
+  }
+  return True;
+}
+
+
+/*
+ * ConnectToTcpAddr connects to the given TCP port.
+ */
+
+int
+ConnectToTcpAddr(unsigned int host, int port)
+{
+  int sock;
+  struct sockaddr_in addr;
+  int one = 1;
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  addr.sin_addr.s_addr = host;
+
+  sock = socket(AF_INET, SOCK_STREAM, 0);
+  if (sock < 0) {
+    perror("krdc: ConnectToTcpAddr: socket");
+    return -(int)INIT_CONNECTION_FAILED;
+  }
+
+  if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    perror("krdc: ConnectToTcpAddr: connect");
+    close(sock);
+    return -(int)INIT_NO_SERVER;
+  }
+
+  if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
+		 (char *)&one, sizeof(one)) < 0) {
+    perror("krdc: ConnectToTcpAddr: setsockopt");
+    close(sock);
+    return -(int)INIT_CONNECTION_FAILED;
+  }
+
+  if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
+    perror(": AcceptTcpConnection: fcntl");
+    close(sock);
+    return -(int)INIT_CONNECTION_FAILED;
+  }  
+
+  return sock;
+}
+
+
+/*
+ * StringToIPAddr - convert a host string to an IP address.
+ */
+
+Bool
+StringToIPAddr(const char *str, unsigned int *addr)
+{
+  struct hostent *hp;
+
+  if (strcmp(str,"") == 0) {
+    *addr = 0; /* local */
+    return True;
+  }
+
+  *addr = inet_addr(str);
+
+  if (*addr != -1)
+    return True;
+
+  hp = gethostbyname(str);
+
+  if (hp) {
+    *addr = *(unsigned int *)hp->h_addr;
+    return True;
+  }
+
+  return False;
+}
+
+
+/*
+ * Print out the contents of a packet for debugging.
+ */
+
+void
+PrintInHex(char *_buf, int len)
+{
+  int i, j;
+  char c, str[17];
+
+  str[16] = 0;
+
+  fprintf(stderr,"ReadExact: ");
+
+  for (i = 0; i < len; i++)
+    {
+      if ((i % 16 == 0) && (i != 0)) {
+	fprintf(stderr,"           ");
+      }
+      c = _buf[i];
+      str[i % 16] = (((c > 31) && (c < 127)) ? c : '.');
+      fprintf(stderr,"%02x ",(unsigned char)c);
+      if ((i % 4) == 3)
+	fprintf(stderr," ");
+      if ((i % 16) == 15)
+	{
+	  fprintf(stderr,"%s\n",str);
+	}
+    }
+  if ((i % 16) != 0)
+    {
+      for (j = i % 16; j < 16; j++)
+	{
+	  fprintf(stderr,"   ");
+	  if ((j % 4) == 3) fprintf(stderr," ");
+	}
+      str[i % 16] = 0;
+      fprintf(stderr,"%s\n",str);
+    }
+
+  fflush(stderr);
+}
+
+void freeSocketsResources() {
+  close(rfbsock);
+
+  errorMessageOnReadFailure = True;
+  bufoutptr = buf;
+  buffered = 0;
+}
+
diff --git a/krdc/vnc/threads.cpp b/krdc/vnc/threads.cpp
new file mode 100644
index 00000000..fe5a1d62
--- /dev/null
+++ b/krdc/vnc/threads.cpp
@@ -0,0 +1,392 @@
+/***************************************************************************
+                            threads.cpp  -  threads
+                             -------------------
+    begin                : Thu May 09 17:01:44 CET 2002
+    copyright            : (C) 2002 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "kvncview.h"
+
+#include <kdebug.h>
+#include <kapplication.h>
+
+#include "vncviewer.h"
+#include "threads.h"
+
+#include <qcstring.h>
+
+// Maximum idle time for writer thread in ms. When it timeouts, it will request
+// another incremental update. Must be smaller than the timeout of the server
+// (krfb's is 20s).
+static const int MAXIMUM_WAIT_PERIOD = 8000;
+
+// time to postpone incremental updates that have not been requested explicitly
+static const int POSTPONED_INCRRQ_WAIT_PERIOD = 110;
+
+static const int MOUSEPRESS_QUEUE_SIZE = 5;
+static const int MOUSEMOVE_QUEUE_SIZE = 3;
+static const int KEY_QUEUE_SIZE = 8192;
+
+
+ControllerThread::ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag) :
+	m_view(v),
+	m_status(REMOTE_VIEW_CONNECTING),
+	m_wthread(wt),
+	m_quitFlag(quitFlag),
+	m_desktopInitialized(false)
+{
+}
+
+void ControllerThread::changeStatus(RemoteViewStatus s) {
+	m_status = s;
+	QApplication::postEvent(m_view, new StatusChangeEvent(s));
+}
+
+void ControllerThread::sendFatalError(ErrorCode s) {
+	m_quitFlag = true;
+	QApplication::postEvent(m_view, new FatalErrorEvent(s));
+	m_wthread.kick();
+}
+
+/*
+ * Calls this from the X11 thread
+ */
+void ControllerThread::desktopInit() {
+	SetVisualAndCmap();
+	ToplevelInit();
+	DesktopInit(m_view->winId());
+	m_desktopInitialized = true;
+	m_waiter.wakeAll();
+}
+
+void ControllerThread::kick() {
+	m_waiter.wakeAll();
+}
+
+void ControllerThread::run() {
+	int fd;
+	fd = ConnectToRFBServer(m_view->host().latin1(), m_view->port());
+	if (fd < 0) {
+		if (fd == -(int)INIT_NO_SERVER)
+			sendFatalError(ERROR_NO_SERVER);
+		else if (fd == -(int)INIT_NAME_RESOLUTION_FAILURE)
+			sendFatalError(ERROR_NAME);
+		else
+			sendFatalError(ERROR_CONNECTION);
+		return;
+	}
+	if (m_quitFlag) {
+		changeStatus(REMOTE_VIEW_DISCONNECTED);
+		return;
+	}
+
+        changeStatus(REMOTE_VIEW_AUTHENTICATING);
+
+	enum InitStatus s = InitialiseRFBConnection();
+	if (s != INIT_OK) {
+		if (s == INIT_CONNECTION_FAILED)
+			sendFatalError(ERROR_IO);
+		else if (s == INIT_SERVER_BLOCKED)
+			sendFatalError(ERROR_SERVER_BLOCKED);
+		else if (s == INIT_PROTOCOL_FAILURE)
+			sendFatalError(ERROR_PROTOCOL);
+		else if (s == INIT_AUTHENTICATION_FAILED)
+			sendFatalError(ERROR_AUTHENTICATION);
+		else if (s == INIT_ABORTED)
+			changeStatus(REMOTE_VIEW_DISCONNECTED);
+		else
+			sendFatalError(ERROR_INTERNAL);
+		return;
+	}
+
+	QApplication::postEvent(m_view,
+				new ScreenResizeEvent(si.framebufferWidth,
+						      si.framebufferHeight));
+	m_wthread.queueUpdateRequest(QRegion(QRect(0,0,si.framebufferWidth,
+		si.framebufferHeight)));
+
+	QApplication::postEvent(m_view, new DesktopInitEvent());
+	while ((!m_quitFlag) && (!m_desktopInitialized))
+		m_waiter.wait(1000);
+
+	if (m_quitFlag) {
+		changeStatus(REMOTE_VIEW_DISCONNECTED);
+		return;
+	}
+
+	changeStatus(REMOTE_VIEW_PREPARING);
+
+	if (!SetFormatAndEncodings()) {
+		sendFatalError(ERROR_INTERNAL);
+		return;
+	}
+
+	changeStatus(REMOTE_VIEW_CONNECTED);
+
+	m_wthread.start();
+
+	while (!m_quitFlag) {
+		if ((!HandleRFBServerMessage()) && (!m_quitFlag)) {
+			sendFatalError(ERROR_IO);
+			return;
+		}
+	}
+
+	m_quitFlag = true;
+	changeStatus(REMOTE_VIEW_DISCONNECTED);
+	m_wthread.kick();
+}
+
+enum RemoteViewStatus ControllerThread::status() {
+	return m_status;
+}
+
+
+
+
+
+static WriterThread *writerThread;
+void queueIncrementalUpdateRequest() {
+	writerThread->queueIncrementalUpdateRequest();
+}
+
+void announceIncrementalUpdateRequest() {
+	writerThread->announceIncrementalUpdateRequest();
+}
+
+
+WriterThread::WriterThread(KVncView *v, volatile bool &quitFlag) :
+	m_quitFlag(quitFlag),
+	m_view(v),
+	m_lastIncrUpdatePostponed(false),
+	m_incrementalUpdateRQ(false),
+	m_incrementalUpdateAnnounced(false),
+	m_mouseEventNum(0),
+	m_keyEventNum(0),
+	m_clientCut(QString::null)
+{
+	writerThread = this;
+	m_lastIncrUpdate.start();
+}
+
+bool WriterThread::sendIncrementalUpdateRequest() {
+	m_lastIncrUpdate.restart();
+	return SendIncrementalFramebufferUpdateRequest();
+}
+
+bool WriterThread::sendUpdateRequest(const QRegion &region) {
+	QMemArray<QRect> r = region.rects();
+	for (unsigned int i = 0; i < r.size(); i++)
+		if (!SendFramebufferUpdateRequest(r[i].x(),
+						  r[i].y(),
+						  r[i].width(),
+						  r[i].height(), False))
+			return false;
+	return true;
+}
+
+bool WriterThread::sendInputEvents(const QValueList<InputEvent> &events) {
+	QValueList<InputEvent>::const_iterator it = events.begin();
+	while (it != events.end()) {
+		if ((*it).type == KeyEventType) {
+			if (!SendKeyEvent((*it).e.k.k, (*it).e.k.down ? True : False))
+				return false;
+		}
+		else
+			if (!SendPointerEvent((*it).e.m.x, (*it).e.m.y, (*it).e.m.buttons))
+				return false;
+		it++;
+	}
+	return true;
+}
+
+void WriterThread::queueIncrementalUpdateRequest() {
+	m_lock.lock();
+	m_incrementalUpdateRQ = true;
+	m_waiter.wakeAll();
+	m_lock.unlock();
+}
+
+void WriterThread::announceIncrementalUpdateRequest() {
+	m_lock.lock();
+	m_incrementalUpdateAnnounced = true;
+	m_lock.unlock();
+}
+
+
+void WriterThread::queueUpdateRequest(const QRegion &r) {
+	m_lock.lock();
+	m_updateRegionRQ += r;
+	m_waiter.wakeAll();
+	m_lock.unlock();
+}
+
+void WriterThread::queueMouseEvent(int x, int y, int buttonMask) {
+	InputEvent e;
+	e.type = MouseEventType;
+	e.e.m.x = x;
+	e.e.m.y = y;
+	e.e.m.buttons = buttonMask;
+
+	m_lock.lock();
+	if (m_mouseEventNum > 0) {
+		if ((e.e.m.x == m_lastMouseEvent.x) &&
+		    (e.e.m.y == m_lastMouseEvent.y) &&
+		    (e.e.m.buttons == m_lastMouseEvent.buttons)) {
+			m_lock.unlock();
+			return;
+		}
+		if (m_mouseEventNum >= MOUSEPRESS_QUEUE_SIZE) {
+			m_lock.unlock();
+			return;
+		}
+		if ((m_lastMouseEvent.buttons == buttonMask) &&
+		    (m_mouseEventNum >= MOUSEMOVE_QUEUE_SIZE)) {
+			m_lock.unlock();
+			return;
+		}
+	}
+
+	m_mouseEventNum++;
+	m_lastMouseEvent = e.e.m;
+
+	m_inputEvents.push_back(e);
+	m_waiter.wakeAll();
+	m_lock.unlock();
+}
+
+void WriterThread::queueKeyEvent(unsigned int k, bool down) {
+	InputEvent e;
+	e.type = KeyEventType;
+	e.e.k.k = k;
+	e.e.k.down = down;
+
+	m_lock.lock();
+	if (m_keyEventNum >= KEY_QUEUE_SIZE) {
+		m_lock.unlock();
+		return;
+	}
+
+	m_keyEventNum++;
+	m_inputEvents.push_back(e);
+	m_waiter.wakeAll();
+	m_lock.unlock();
+}
+
+void WriterThread::queueClientCut(const QString &text) {
+	m_lock.lock();
+
+	m_clientCut = text;
+
+	m_waiter.wakeAll();
+	m_lock.unlock();
+}
+
+void WriterThread::kick() {
+	m_waiter.wakeAll();
+}
+
+void WriterThread::run() {
+	bool incrementalUpdateRQ = false;
+	bool incrementalUpdateAnnounced = false;
+	QRegion updateRegionRQ;
+	QValueList<InputEvent> inputEvents;
+	QString clientCut;
+
+	while (!m_quitFlag) {
+		m_lock.lock();
+		incrementalUpdateRQ = m_incrementalUpdateRQ;
+		incrementalUpdateAnnounced = m_incrementalUpdateAnnounced;
+		updateRegionRQ = m_updateRegionRQ;
+		inputEvents = m_inputEvents;
+		clientCut = m_clientCut;
+
+		if ((!incrementalUpdateRQ) &&
+		    (updateRegionRQ.isNull()) &&
+		    (inputEvents.size() == 0) &&
+		    (clientCut.isNull())) {
+			if (!m_waiter.wait(&m_lock,
+					   m_lastIncrUpdatePostponed ?
+					   POSTPONED_INCRRQ_WAIT_PERIOD : MAXIMUM_WAIT_PERIOD))
+				m_incrementalUpdateRQ = true;
+			m_lock.unlock();
+		}
+		else {
+			m_incrementalUpdateRQ = false;
+			m_incrementalUpdateAnnounced = false;
+			m_updateRegionRQ = QRegion();
+			m_inputEvents.clear();
+			m_keyEventNum = 0;
+			m_mouseEventNum = 0;
+			m_clientCut = QString::null;
+			m_lock.unlock();
+
+			// always send incremental update, unless
+			// a) a framebuffer update is done ATM and will do the request later, or
+			// b) the last unrequested update has been done less than 0.1s ago
+			//
+			// if the update has not been done because of b, postpone it.
+			if (incrementalUpdateRQ || !incrementalUpdateAnnounced) {
+				bool sendUpdate;
+				if (incrementalUpdateRQ) {
+					sendUpdate = true;
+					m_lastIncrUpdatePostponed = false;
+				}
+				else {
+					if (m_lastIncrUpdate.elapsed() < 100) {
+						sendUpdate = false;
+						m_lastIncrUpdatePostponed = true;
+					}
+					else {
+						sendUpdate = true;
+						m_lastIncrUpdatePostponed = false;
+					}
+				}
+
+				if (sendUpdate)
+					if (!sendIncrementalUpdateRequest()) {
+						sendFatalError(ERROR_IO);
+						break;
+					}
+			}
+			else
+				m_lastIncrUpdatePostponed = false;
+
+			if (!updateRegionRQ.isNull())
+				if (!sendUpdateRequest(updateRegionRQ)) {
+					sendFatalError(ERROR_IO);
+					break;
+				}
+			if (inputEvents.size() != 0)
+				if (!sendInputEvents(inputEvents)) {
+					sendFatalError(ERROR_IO);
+					break;
+				}
+			if (!clientCut.isNull())  {
+				QCString cutTextUtf8(clientCut.utf8());
+				if (!SendClientCutText(cutTextUtf8.data(),
+						       (int)cutTextUtf8.length())) {
+					sendFatalError(ERROR_IO);
+					break;
+				}
+			}
+		}
+	}
+	m_quitFlag = true;
+}
+
+void WriterThread::sendFatalError(ErrorCode s) {
+	m_quitFlag = true;
+	QApplication::postEvent(m_view, new FatalErrorEvent(s));
+}
+
diff --git a/krdc/vnc/threads.h b/krdc/vnc/threads.h
new file mode 100644
index 00000000..5f38b71f
--- /dev/null
+++ b/krdc/vnc/threads.h
@@ -0,0 +1,126 @@
+/***************************************************************************
+                          threads.h  -  threads for kvncview
+                             -------------------
+    begin                : Thu May 09 16:01:42 CET 2002
+    copyright            : (C) 2002 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef THREADS_H
+#define THREADS_H
+
+#include <qthread.h>
+#include <qregion.h>
+#include <qrect.h>
+#include <qmutex.h>
+#include <qwaitcondition.h>
+#include <qevent.h>
+#include <qvaluelist.h>
+#include <qdatetime.h>
+
+#include <stdlib.h> 
+
+#include "events.h"
+#include "vnctypes.h"
+
+class KVncView;
+
+enum EventType {
+	MouseEventType,
+	KeyEventType
+};
+
+
+struct MouseEvent {
+	int x, y, buttons;
+};
+
+struct KeyEvent {
+	unsigned int k;
+	bool down;
+};
+
+struct InputEvent {
+	EventType type;
+	union {
+		MouseEvent m;
+		KeyEvent k;
+	} e;
+};
+
+
+class WriterThread : public QThread {
+private:
+	QMutex m_lock;
+	QWaitCondition m_waiter;
+	volatile bool &m_quitFlag;
+	KVncView *m_view;
+
+	QTime m_lastIncrUpdate; // start()ed when a incr update is sent
+	bool m_lastIncrUpdatePostponed;
+
+	// all things that can be send follow:
+	bool m_incrementalUpdateRQ; // for sending an incremental request
+	bool m_incrementalUpdateAnnounced; // set when a RQ will come soon
+	QRegion m_updateRegionRQ;  // for sending updates, null if it is done
+	QValueList<InputEvent> m_inputEvents; // list of unsent input events
+	MouseEvent m_lastMouseEvent;
+	int m_mouseEventNum, m_keyEventNum;
+	QString m_clientCut;
+
+	void sendFatalError(ErrorCode s);
+
+public:
+	WriterThread(KVncView *v, volatile bool &quitFlag);
+	
+	void queueIncrementalUpdateRequest();
+	void announceIncrementalUpdateRequest();
+	void queueUpdateRequest(const QRegion &r);
+	void queueMouseEvent(int x, int y, int buttonMask);
+	void queueKeyEvent(unsigned int k, bool down);
+	void queueClientCut(const QString &text);
+	void kick();
+	
+protected:
+	void run();
+	bool sendIncrementalUpdateRequest();
+	bool sendUpdateRequest(const QRegion &r);
+	bool sendInputEvents(const QValueList<InputEvent> &events);
+};
+
+
+
+class ControllerThread : public QThread { 
+private:
+	KVncView *m_view;
+	enum RemoteViewStatus m_status;
+	WriterThread &m_wthread;
+	volatile bool &m_quitFlag;
+	volatile bool m_desktopInitialized;
+	QWaitCondition m_waiter;
+
+	void changeStatus(RemoteViewStatus s);
+	void sendFatalError(ErrorCode s);
+
+public:
+	ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag);
+	enum RemoteViewStatus status();	
+	void desktopInit();
+	void kick();
+
+protected:
+	void run();
+};
+
+
+
+#endif
diff --git a/krdc/vnc/tight.c b/krdc/vnc/tight.c
new file mode 100644
index 00000000..2f08cfb0
--- /dev/null
+++ b/krdc/vnc/tight.c
@@ -0,0 +1,610 @@
+/*
+ *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * tight.c - handle ``tight'' encoding.
+ *
+ * This file shouldn't be compiled directly. It is included multiple
+ * times by rfbproto.c, each time with a different definition of the
+ * macro BPP. For each value of BPP, this file defines a function
+ * which handles a tight-encoded rectangle with BPP bits per pixel.
+ *
+ */
+
+#define TIGHT_MIN_TO_COMPRESS 12
+
+#define CARDBPP CONCAT2E(CARD,BPP)
+#define filterPtrBPP CONCAT2E(filterPtr,BPP)
+
+#define HandleTightBPP CONCAT2E(HandleTight,BPP)
+#define InitFilterCopyBPP CONCAT2E(InitFilterCopy,BPP)
+#define InitFilterPaletteBPP CONCAT2E(InitFilterPalette,BPP)
+#define InitFilterGradientBPP CONCAT2E(InitFilterGradient,BPP)
+#define FilterCopyBPP CONCAT2E(FilterCopy,BPP)
+#define FilterPaletteBPP CONCAT2E(FilterPalette,BPP)
+#define FilterGradientBPP CONCAT2E(FilterGradient,BPP)
+#define FillRectangleBPP CONCAT2E(FillRectangle,BPP)
+
+#if BPP != 8
+#define DecompressJpegRectBPP CONCAT2E(DecompressJpegRect,BPP)
+#endif
+
+#ifndef RGB_TO_PIXEL
+
+#define RGB_TO_PIXEL(bpp,r,g,b)						\
+  (((CARD##bpp)(r) & myFormat.redMax) << myFormat.redShift |		\
+   ((CARD##bpp)(g) & myFormat.greenMax) << myFormat.greenShift |	\
+   ((CARD##bpp)(b) & myFormat.blueMax) << myFormat.blueShift)
+
+#define RGB24_TO_PIXEL(bpp,r,g,b)                                       \
+   ((((CARD##bpp)(r) & 0xFF) * myFormat.redMax + 127) / 255             \
+    << myFormat.redShift |                                              \
+    (((CARD##bpp)(g) & 0xFF) * myFormat.greenMax + 127) / 255           \
+    << myFormat.greenShift |                                            \
+    (((CARD##bpp)(b) & 0xFF) * myFormat.blueMax + 127) / 255            \
+    << myFormat.blueShift)
+
+#define RGB24_TO_PIXEL32(r,g,b)						\
+  (((CARD32)(r) & 0xFF) << myFormat.redShift |				\
+   ((CARD32)(g) & 0xFF) << myFormat.greenShift |			\
+   ((CARD32)(b) & 0xFF) << myFormat.blueShift)
+
+#endif
+
+/* Type declarations */
+
+typedef void (*filterPtrBPP)(int, CARDBPP *);
+
+/* Prototypes */
+
+static int InitFilterCopyBPP (int rw, int rh);
+static int InitFilterPaletteBPP (int rw, int rh);
+static int InitFilterGradientBPP (int rw, int rh);
+static void FilterCopyBPP (int numRows, CARDBPP *destBuffer);
+static void FilterPaletteBPP (int numRows, CARDBPP *destBuffer);
+static void FilterGradientBPP (int numRows, CARDBPP *destBuffer);
+
+static Bool DecompressJpegRectBPP(int x, int y, int w, int h);
+
+/* Definitions */
+
+static Bool
+HandleTightBPP (int rx, int ry, int rw, int rh)
+{
+  CARDBPP fill_colour;
+  XGCValues gcv;
+  CARD8 comp_ctl;
+  CARD8 filter_id;
+  filterPtrBPP filterFn;
+  z_streamp zs;
+  char *buffer2;
+  int err, stream_id, compressedLen, bitsPixel;
+  int bufferSize, rowSize, numRows, portionLen, rowsProcessed, extraBytes;
+  CARDBPP *rawData;
+
+  if (!ReadFromRFBServer((char *)&comp_ctl, 1))
+    return False;
+
+  /* Flush zlib streams if we are told by the server to do so. */
+  for (stream_id = 0; stream_id < 4; stream_id++) {
+    if ((comp_ctl & 1) && zlibStreamActive[stream_id]) {
+      if (inflateEnd (&zlibStream[stream_id]) != Z_OK &&
+	  zlibStream[stream_id].msg != NULL)
+	fprintf(stderr, "inflateEnd: %s\n", zlibStream[stream_id].msg);
+      zlibStreamActive[stream_id] = False;
+    }
+    comp_ctl >>= 1;
+  }
+
+  /* Handle solid rectangles. */
+  if (comp_ctl == rfbTightFill) {
+#if BPP == 32
+    if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
+	myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
+      if (!ReadFromRFBServer(buffer, 3))
+	return False;
+      fill_colour = RGB24_TO_PIXEL32(buffer[0], buffer[1], buffer[2]);
+    } else {
+      if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour)))
+	return False;
+    }
+#else
+    if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour)))
+	return False;
+#endif
+    
+    LockFramebuffer();
+    FillRectangleBPP(fill_colour, rx, ry, rw, rh);
+    UnlockFramebuffer();
+    SyncScreenRegion(rx, ry, rw, rh);
+    return True;
+  }
+
+#if BPP == 8
+  if (comp_ctl == rfbTightJpeg) {
+    fprintf(stderr, "Tight encoding: JPEG is not supported in 8 bpp mode.\n");
+    return False;
+  }
+#else
+  if (comp_ctl == rfbTightJpeg) {
+    return DecompressJpegRectBPP(rx, ry, rw, rh);
+  }
+#endif
+
+  /* Quit on unsupported subencoding value. */
+  if (comp_ctl > rfbTightMaxSubencoding) {
+    fprintf(stderr, "Tight encoding: bad subencoding value received.\n");
+    return False;
+  }
+
+  /*
+   * Here primary compression mode handling begins.
+   * Data was processed with optional filter + zlib compression.
+   */
+
+  /* First, we should identify a filter to use. */
+  if ((comp_ctl & rfbTightExplicitFilter) != 0) {
+    if (!ReadFromRFBServer((char*)&filter_id, 1))
+      return False;
+
+    switch (filter_id) {
+    case rfbTightFilterCopy:
+      filterFn = FilterCopyBPP;
+      bitsPixel = InitFilterCopyBPP(rw, rh);
+      break;
+    case rfbTightFilterPalette:
+      filterFn = FilterPaletteBPP;
+      bitsPixel = InitFilterPaletteBPP(rw, rh);
+      break;
+    case rfbTightFilterGradient:
+      filterFn = FilterGradientBPP;
+      bitsPixel = InitFilterGradientBPP(rw, rh);
+      break;
+    default:
+      fprintf(stderr, "Tight encoding: unknown filter code received.\n");
+      return False;
+    }
+  } else {
+    filterFn = FilterCopyBPP;
+    bitsPixel = InitFilterCopyBPP(rw, rh);
+  }
+  if (bitsPixel == 0) {
+    fprintf(stderr, "Tight encoding: error receiving palette.\n");
+    return False;
+  }
+
+  /* Determine if the data should be decompressed or just copied. */
+  rowSize = (rw * bitsPixel + 7) / 8;
+  if (rh * rowSize < TIGHT_MIN_TO_COMPRESS) {
+    if (!ReadFromRFBServer((char*)buffer, rh * rowSize))
+      return False;
+
+    buffer2 = &buffer[TIGHT_MIN_TO_COMPRESS * 4];
+    filterFn(rh, (CARDBPP *)buffer2);
+    CopyDataToScreen(buffer2, rx, ry, rw, rh);
+
+    return True;
+  }
+
+  /* Read the length (1..3 bytes) of compressed data following. */
+  compressedLen = (int)ReadCompactLen();
+  if (compressedLen <= 0) {
+    fprintf(stderr, "Incorrect data received from the server.\n");
+    return False;
+  }
+
+  /* Now let's initialize compression stream if needed. */
+  stream_id = comp_ctl & 0x03;
+  zs = &zlibStream[stream_id];
+  if (!zlibStreamActive[stream_id]) {
+    zs->zalloc = Z_NULL;
+    zs->zfree = Z_NULL;
+    zs->opaque = Z_NULL;
+    err = inflateInit(zs);
+    if (err != Z_OK) {
+      if (zs->msg != NULL)
+	fprintf(stderr, "InflateInit error: %s.\n", zs->msg);
+      return False;
+    }
+    zlibStreamActive[stream_id] = True;
+  }
+
+  /* Read, decode and draw actual pixel data in a loop. */
+
+  bufferSize = BUFFER_SIZE * bitsPixel / (bitsPixel + BPP) & 0xFFFFFFFC;
+  buffer2 = &buffer[bufferSize];
+  if (rowSize > bufferSize) {
+    /* Should be impossible when BUFFER_SIZE >= 16384 */
+    fprintf(stderr, "Internal error: incorrect buffer size.\n");
+    return False;
+  }
+
+  rowsProcessed = 0;
+  extraBytes = 0;
+
+  while (compressedLen > 0) {
+    if (compressedLen > ZLIB_BUFFER_SIZE)
+      portionLen = ZLIB_BUFFER_SIZE;
+    else
+      portionLen = compressedLen;
+
+    if (!ReadFromRFBServer((char*)zlib_buffer, portionLen))
+      return False;
+
+    compressedLen -= portionLen;
+
+    zs->next_in = (Bytef *)zlib_buffer;
+    zs->avail_in = portionLen;
+
+    do {
+      zs->next_out = (Bytef *)&buffer[extraBytes];
+      zs->avail_out = bufferSize - extraBytes;
+
+      err = inflate(zs, Z_SYNC_FLUSH);
+      if (err == Z_BUF_ERROR)   /* Input exhausted -- no problem. */
+	break;
+      if (err != Z_OK && err != Z_STREAM_END) {
+	if (zs->msg != NULL) {
+	  fprintf(stderr, "Inflate error: %s.\n", zs->msg);
+	} else {
+	  fprintf(stderr, "Inflate error: %d.\n", err);
+	}
+	return False;
+      }
+
+      numRows = (bufferSize - zs->avail_out) / rowSize;
+
+      filterFn(numRows, (CARDBPP *)buffer2);
+
+      extraBytes = bufferSize - zs->avail_out - numRows * rowSize;
+      if (extraBytes > 0)
+	memcpy(buffer, &buffer[numRows * rowSize], extraBytes);
+
+      CopyDataToScreen(buffer2, rx, ry + rowsProcessed, rw, numRows);
+      rowsProcessed += numRows;
+    }
+    while (zs->avail_out == 0);
+  }
+
+  if (rowsProcessed != rh) {
+    fprintf(stderr, "Incorrect number of scan lines after decompression.\n");
+    return False;
+  }
+
+  return True;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * Filter stuff.
+ *
+ */
+
+/*
+   The following variables are defined in rfbproto.c:
+     static Bool cutZeros;
+     static int rectWidth, rectColors;
+     static CARD8 tightPalette[256*4];
+     static CARD8 tightPrevRow[2048*3*sizeof(CARD16)];
+*/
+
+static int
+InitFilterCopyBPP (int rw, int rh)
+{
+  rectWidth = rw;
+
+#if BPP == 32
+  if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
+      myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
+    cutZeros = True;
+    return 24;
+  } else {
+    cutZeros = False;
+  }
+#endif
+
+  return BPP;
+}
+
+static void
+FilterCopyBPP (int numRows, CARDBPP *dst)
+{
+
+#if BPP == 32
+  int x, y;
+
+  if (cutZeros) {
+    for (y = 0; y < numRows; y++) {
+      for (x = 0; x < rectWidth; x++) {
+	dst[y*rectWidth+x] =
+	  RGB24_TO_PIXEL32(buffer[(y*rectWidth+x)*3],
+			   buffer[(y*rectWidth+x)*3+1],
+			   buffer[(y*rectWidth+x)*3+2]);
+      }
+    }
+    return;
+  }
+#endif
+
+  memcpy (dst, buffer, numRows * rectWidth * (BPP / 8));
+}
+
+static int
+InitFilterGradientBPP (int rw, int rh)
+{
+  int bits;
+
+  bits = InitFilterCopyBPP(rw, rh);
+  if (cutZeros)
+    memset(tightPrevRow, 0, rw * 3);
+  else
+    memset(tightPrevRow, 0, rw * 3 * sizeof(CARD16));
+
+  return bits;
+}
+
+#if BPP == 32
+
+static void
+FilterGradient24 (int numRows, CARD32 *dst)
+{
+  int x, y, c;
+  CARD8 thisRow[2048*3];
+  CARD8 pix[3];
+  int est[3];
+
+  for (y = 0; y < numRows; y++) {
+
+    /* First pixel in a row */
+    for (c = 0; c < 3; c++) {
+      pix[c] = tightPrevRow[c] + buffer[y*rectWidth*3+c];
+      thisRow[c] = pix[c];
+    }
+    dst[y*rectWidth] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
+
+    /* Remaining pixels of a row */
+    for (x = 1; x < rectWidth; x++) {
+      for (c = 0; c < 3; c++) {
+	est[c] = (int)tightPrevRow[x*3+c] + (int)pix[c] -
+		 (int)tightPrevRow[(x-1)*3+c];
+	if (est[c] > 0xFF) {
+	  est[c] = 0xFF;
+	} else if (est[c] < 0x00) {
+	  est[c] = 0x00;
+	}
+	pix[c] = (CARD8)est[c] + buffer[(y*rectWidth+x)*3+c];
+	thisRow[x*3+c] = pix[c];
+      }
+      dst[y*rectWidth+x] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
+    }
+
+    memcpy(tightPrevRow, thisRow, rectWidth * 3);
+  }
+}
+
+#endif
+
+static void
+FilterGradientBPP (int numRows, CARDBPP *dst)
+{
+  int x, y, c;
+  CARDBPP *src = (CARDBPP *)buffer;
+  CARD16 *thatRow = (CARD16 *)tightPrevRow;
+  CARD16 thisRow[2048*3];
+  CARD16 pix[3];
+  CARD16 max[3];
+  int shift[3];
+  int est[3];
+
+#if BPP == 32
+  if (cutZeros) {
+    FilterGradient24(numRows, dst);
+    return;
+  }
+#endif
+
+  max[0] = myFormat.redMax;
+  max[1] = myFormat.greenMax;
+  max[2] = myFormat.blueMax;
+
+  shift[0] = myFormat.redShift;
+  shift[1] = myFormat.greenShift;
+  shift[2] = myFormat.blueShift;
+
+  for (y = 0; y < numRows; y++) {
+
+    /* First pixel in a row */
+    for (c = 0; c < 3; c++) {
+      pix[c] = (CARD16)((src[y*rectWidth] >> shift[c]) + thatRow[c] & max[c]);
+      thisRow[c] = pix[c];
+    }
+    dst[y*rectWidth] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
+
+    /* Remaining pixels of a row */
+    for (x = 1; x < rectWidth; x++) {
+      for (c = 0; c < 3; c++) {
+	est[c] = (int)thatRow[x*3+c] + (int)pix[c] - (int)thatRow[(x-1)*3+c];
+	if (est[c] > (int)max[c]) {
+	  est[c] = (int)max[c];
+	} else if (est[c] < 0) {
+	  est[c] = 0;
+	}
+	pix[c] = (CARD16)((src[y*rectWidth+x] >> shift[c]) + est[c] & max[c]);
+	thisRow[x*3+c] = pix[c];
+      }
+      dst[y*rectWidth+x] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
+    }
+    memcpy(thatRow, thisRow, rectWidth * 3 * sizeof(CARD16));
+  }
+}
+
+static int
+InitFilterPaletteBPP (int rw, int rh)
+{
+  int i;
+  CARD8 numColors;
+  CARDBPP *palette = (CARDBPP *)tightPalette;
+
+  rectWidth = rw;
+
+  if (!ReadFromRFBServer((char*)&numColors, 1))
+    return 0;
+
+  rectColors = (int)numColors;
+  if (++rectColors < 2)
+    return 0;
+
+#if BPP == 32
+  if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
+      myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
+    if (!ReadFromRFBServer((char*)&tightPalette, rectColors * 3))
+      return 0;
+    for (i = rectColors - 1; i >= 0; i--) {
+      palette[i] = RGB24_TO_PIXEL32(tightPalette[i*3],
+				    tightPalette[i*3+1],
+				    tightPalette[i*3+2]);
+    }
+    return (rectColors == 2) ? 1 : 8;
+  }
+#endif
+
+  if (!ReadFromRFBServer((char*)&tightPalette, rectColors * (BPP / 8)))
+    return 0;
+
+  return (rectColors == 2) ? 1 : 8;
+}
+
+static void
+FilterPaletteBPP (int numRows, CARDBPP *dst)
+{
+  int x, y, b, w;
+  CARD8 *src = (CARD8 *)buffer;
+  CARDBPP *palette = (CARDBPP *)tightPalette;
+
+  if (rectColors == 2) {
+    w = (rectWidth + 7) / 8;
+    for (y = 0; y < numRows; y++) {
+      for (x = 0; x < rectWidth / 8; x++) {
+	for (b = 7; b >= 0; b--)
+	  dst[y*rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1];
+      }
+      for (b = 7; b >= 8 - rectWidth % 8; b--) {
+	dst[y*rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1];
+      }
+    }
+  } else {
+    for (y = 0; y < numRows; y++)
+      for (x = 0; x < rectWidth; x++)
+	dst[y*rectWidth+x] = palette[(int)src[y*rectWidth+x]];
+  }
+}
+
+#if BPP != 8
+
+/*----------------------------------------------------------------------------
+ *
+ * JPEG decompression.
+ *
+ */
+
+/*
+   The following variables are defined in rfbproto.c:
+     static Bool jpegError;
+     static struct jpeg_source_mgr jpegSrcManager;
+     static JOCTET *jpegBufferPtr;
+     static size_t *jpegBufferLen;
+*/
+
+static Bool
+DecompressJpegRectBPP(int x, int y, int w, int h)
+{
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  int compressedLen;
+  CARD8 *compressedData;
+  CARDBPP *pixelPtr;
+  JSAMPROW rowPointer[1];
+  int dx, dy;
+
+  compressedLen = (int)ReadCompactLen();
+  if (compressedLen <= 0) {
+    fprintf(stderr, "Incorrect data received from the server.\n");
+    return False;
+  }
+
+  if (compressedLen > MAX_JPEG_SIZE) {
+    fprintf(stderr, "To large data announced by the server.\n");
+    return False;
+  }
+
+  compressedData = malloc(compressedLen);
+  if (compressedData == NULL) {
+    fprintf(stderr, "Memory allocation error.\n");
+    return False;
+  }
+
+  if (!ReadFromRFBServer((char*)compressedData, compressedLen)) {
+    free(compressedData);
+    return False;
+  }
+
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_decompress(&cinfo);
+
+  JpegSetSrcManager(&cinfo, compressedData, compressedLen);
+
+  jpeg_read_header(&cinfo, TRUE);
+  cinfo.out_color_space = JCS_RGB;
+
+  jpeg_start_decompress(&cinfo);
+  if (cinfo.output_width != w || cinfo.output_height != h ||
+      cinfo.output_components != 3) {
+    fprintf(stderr, "Tight Encoding: Wrong JPEG data received.\n");
+    jpeg_destroy_decompress(&cinfo);
+    free(compressedData);
+    return False;
+  }
+
+  rowPointer[0] = (JSAMPROW)buffer;
+  dy = 0;
+  while (cinfo.output_scanline < cinfo.output_height) {
+    jpeg_read_scanlines(&cinfo, rowPointer, 1);
+    if (jpegError) {
+      break;
+    }
+    pixelPtr = (CARDBPP *)&buffer[BUFFER_SIZE / 2];
+    for (dx = 0; dx < w; dx++) {
+      *pixelPtr++ =
+	RGB24_TO_PIXEL(BPP, buffer[dx*3], buffer[dx*3+1], buffer[dx*3+2]);
+    }
+    CopyDataToScreen(&buffer[BUFFER_SIZE / 2], x, y + dy, w, 1);
+    dy++;
+  }
+
+  if (!jpegError)
+    jpeg_finish_decompress(&cinfo);
+
+  jpeg_destroy_decompress(&cinfo);
+  free(compressedData);
+
+  return !jpegError;
+}
+
+#endif
+
diff --git a/krdc/vnc/vncauth.c b/krdc/vnc/vncauth.c
new file mode 100644
index 00000000..b5d42836
--- /dev/null
+++ b/krdc/vnc/vncauth.c
@@ -0,0 +1,161 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  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.
+ */
+
+/*
+ * vncauth.c - Functions for VNC password management and authentication.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <vncauth.h>
+#include <d3des.h>
+
+
+/*
+ * We use a fixed key to store passwords, since we assume that our local
+ * file system is secure but nonetheless don't want to store passwords
+ * as plaintext.
+ */
+
+unsigned char fixedkey[8] = {23,82,107,6,35,78,88,7};
+
+
+/*
+ * Encrypt a password and store it in a file.  Returns 0 if successful,
+ * 1 if the file could not be written.
+ */
+
+int
+vncEncryptAndStorePasswd(char *passwd, char *fname)
+{
+    FILE *fp;
+    int i;
+    unsigned char encryptedPasswd[8];
+
+    if ((fp = fopen(fname,"w")) == NULL) return 1;
+
+    chmod(fname, S_IRUSR|S_IWUSR);
+
+    /* pad password with nulls */
+
+    for (i = 0; i < 8; i++) {
+	if (i < strlen(passwd)) {
+	    encryptedPasswd[i] = passwd[i];
+	} else {
+	    encryptedPasswd[i] = 0;
+	}
+    }
+
+    /* Do encryption in-place - this way we overwrite our copy of the plaintext
+       password */
+
+    deskey(fixedkey, EN0);
+    des(encryptedPasswd, encryptedPasswd);
+
+    for (i = 0; i < 8; i++) {
+	putc(encryptedPasswd[i], fp);
+    }
+  
+    fclose(fp);
+    return 0;
+}
+
+
+/*
+ * Decrypt a password from a file.  Returns a pointer to a newly allocated
+ * string containing the password or a null pointer if the password could
+ * not be retrieved for some reason.
+ */
+
+char *
+vncDecryptPasswdFromFile(char *fname)
+{
+    FILE *fp;
+    int i, ch;
+    unsigned char *passwd = (unsigned char *)malloc(9);
+
+    if ((fp = fopen(fname,"r")) == NULL) return NULL;
+
+    for (i = 0; i < 8; i++) {
+	ch = getc(fp);
+	if (ch == EOF) {
+	    fclose(fp);
+	    return NULL;
+	}
+	passwd[i] = ch;
+    }
+
+    fclose(fp);
+
+    deskey(fixedkey, DE1);
+    des(passwd, passwd);
+
+    passwd[8] = 0;
+
+    return (char *)passwd;
+}
+
+
+/*
+ * Generate CHALLENGESIZE random bytes for use in challenge-response
+ * authentication.
+ */
+
+void
+vncRandomBytes(unsigned char *bytes)
+{
+    int i;
+    unsigned int seed = (unsigned int) time(0);
+
+    srandom(seed);
+    for (i = 0; i < CHALLENGESIZE; i++) {
+	bytes[i] = (unsigned char)(random() & 255);    
+    }
+}
+
+
+/*
+ * Encrypt CHALLENGESIZE bytes in memory using a password.
+ */
+
+void
+vncEncryptBytes(unsigned char *bytes, char *passwd)
+{
+    unsigned char key[8];
+    int i;
+
+    /* key is simply password padded with nulls */
+
+    for (i = 0; i < 8; i++) {
+	if (i < strlen(passwd)) {
+	    key[i] = passwd[i];
+	} else {
+	    key[i] = 0;
+	}
+    }
+
+    deskey(key, EN0);
+
+    for (i = 0; i < CHALLENGESIZE; i += 8) {
+	des(bytes+i, bytes+i);
+    }
+}
diff --git a/krdc/vnc/vncauth.h b/krdc/vnc/vncauth.h
new file mode 100644
index 00000000..86dc455c
--- /dev/null
+++ b/krdc/vnc/vncauth.h
@@ -0,0 +1,30 @@
+/*
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/* 
+ * vncauth.h - describes the functions provided by the vncauth library.
+ */
+
+#define MAXPWLEN 8
+#define CHALLENGESIZE 16
+
+extern int vncEncryptAndStorePasswd(char *passwd, char *fname);
+extern char *vncDecryptPasswdFromFile(char *fname);
+extern void vncRandomBytes(unsigned char *bytes);
+extern void vncEncryptBytes(unsigned char *bytes, char *passwd);
diff --git a/krdc/vnc/vnchostpref.cpp b/krdc/vnc/vnchostpref.cpp
new file mode 100644
index 00000000..a17f8ea1
--- /dev/null
+++ b/krdc/vnc/vnchostpref.cpp
@@ -0,0 +1,127 @@
+/***************************************************************************
+                      vnchostprefs.cpp  -  vnc host preferences
+                             -------------------
+    begin                : Fri May 09 22:32 CET 2003
+    copyright            : (C) 2003 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "vnchostpref.h"
+#include <kconfig.h>
+#include <klocale.h>
+
+const QString VncHostPref::VncType = "VNC";
+
+VncHostPref::VncHostPref(KConfig *conf, const QString &host, const QString &type) :
+	HostPref(conf, host, type),
+	m_quality(0),
+	m_useKWallet(true),
+	m_askOnConnect(true) {
+}
+
+VncHostPref::~VncHostPref() {
+}
+
+void VncHostPref::save() {
+	if ( !m_host.isEmpty() && !m_type.isEmpty() )
+	{
+		m_config->setGroup("PerHostSettings");
+		QString p = prefix();
+		m_config->writeEntry(p+"exists", true);
+		m_config->writeEntry(p+"quality", m_quality);
+		m_config->writeEntry(p+"askOnConnect", m_askOnConnect);
+		m_config->writeEntry(p+"useKWallet", m_useKWallet);
+	}
+	else
+	{
+		m_config->setGroup( "VncDefaultSettings" );
+		m_config->writeEntry( "vncQuality", m_quality );
+		m_config->writeEntry( "vncShowHostPreferences", m_askOnConnect );
+		m_config->writeEntry( "vncUseKWallet", m_useKWallet );
+	}
+}
+
+void VncHostPref::load() {
+	if ( !m_host.isEmpty() && !m_type.isEmpty() )
+	{
+		m_config->setGroup("PerHostSettings");
+		QString p = prefix();
+		m_quality = m_config->readNumEntry(p+"quality", 0);
+		m_askOnConnect = m_config->readBoolEntry(p+"askOnConnect", true);
+		m_useKWallet = m_config->readBoolEntry(p+"useKWallet", true);
+	}
+	else
+	{
+		setDefaults();
+	}
+}
+
+void VncHostPref::remove() {
+	m_config->setGroup("PerHostSettings");
+	QString p = prefix();
+	m_config->deleteEntry(p+"exists");
+	m_config->deleteEntry(p+"quality");
+	m_config->deleteEntry(p+"askOnConnect");
+}
+
+void VncHostPref::setDefaults() {
+	m_config->setGroup("VncDefaultSettings");
+	m_quality = m_config->readNumEntry("vncQuality", 0);
+	m_askOnConnect = m_config->readBoolEntry("vncShowHostPreferences", true);
+	m_useKWallet = m_config->readBoolEntry("vncUseKWallet", true);
+}
+
+QString VncHostPref::prefDescription() const {
+	QString q;
+	switch(m_quality) {
+	case 0:
+		q = i18n("High");
+		break;
+	case 1:
+		q = i18n("Medium");
+		break;
+	case 2:
+		q = i18n("Low");
+		break;
+	default:
+		Q_ASSERT(true);
+	}
+	return i18n("Show Preferences: %1, Quality: %2, KWallet: %3")
+	  .arg(m_askOnConnect ? i18n("yes") : i18n("no")).arg(q).arg(m_useKWallet ? i18n("yes") : i18n("no"));
+}
+
+void VncHostPref::setQuality(int q) {
+	m_quality = q;
+	save();
+}
+
+int VncHostPref::quality() const {
+	return m_quality;
+}
+
+void VncHostPref::setAskOnConnect(bool ask) {
+	m_askOnConnect = ask;
+	save();
+}
+
+bool VncHostPref::askOnConnect() const {
+	return m_askOnConnect;
+}
+
+void VncHostPref::setUseKWallet(bool use) {
+	m_useKWallet = use;
+	save();
+}
+
+bool VncHostPref::useKWallet() const {
+	return m_useKWallet;
+}
diff --git a/krdc/vnc/vnchostpref.h b/krdc/vnc/vnchostpref.h
new file mode 100644
index 00000000..33a20600
--- /dev/null
+++ b/krdc/vnc/vnchostpref.h
@@ -0,0 +1,52 @@
+/***************************************************************************
+                       vnchostprefs.h  -  vnc host preferences
+                             -------------------
+    begin                : Fri May 09 22:32 CET 2003
+    copyright            : (C) 2003 by Tim Jansen
+    email                : tim@tjansen.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef VNCHOSTPREF_H
+#define VNCHOSTPREF_H
+
+#include "hostpreferences.h"
+
+class VncHostPref : public HostPref {
+protected:
+	friend class HostPreferences;
+
+	int m_quality;
+	bool m_askOnConnect;
+	bool m_useKWallet;
+
+	virtual void load();
+	virtual void setDefaults();
+	virtual void save();
+	virtual void remove();
+
+public:
+	static const QString VncType;
+
+	VncHostPref(KConfig *conf, const QString &host=QString::null,
+		const QString &type=QString::null);
+	virtual ~VncHostPref();
+	
+	virtual QString prefDescription() const;
+	void setQuality(int q);
+	int quality() const;
+	void setAskOnConnect(bool ask);
+	bool askOnConnect() const;
+	void setUseKWallet(bool);
+	bool useKWallet() const;
+};
+
+#endif
diff --git a/krdc/vnc/vncprefs.ui b/krdc/vnc/vncprefs.ui
new file mode 100644
index 00000000..034b2b1a
--- /dev/null
+++ b/krdc/vnc/vncprefs.ui
@@ -0,0 +1,165 @@
+<!DOCTYPE UI><UI version="3.2" stdsetdef="1">
+<class>VncPrefs</class>
+<widget class="QWidget">
+    <property name="name">
+        <cstring>VncPrefs</cstring>
+    </property>
+    <property name="geometry">
+        <rect>
+            <x>0</x>
+            <y>0</y>
+            <width>472</width>
+            <height>126</height>
+        </rect>
+    </property>
+    <vbox>
+        <property name="name">
+            <cstring>unnamed</cstring>
+        </property>
+        <property name="margin">
+            <number>0</number>
+        </property>
+        <widget class="QGroupBox">
+            <property name="name">
+                <cstring>groupBox</cstring>
+            </property>
+            <property name="title">
+                <string>Connection</string>
+            </property>
+            <grid>
+                <property name="name">
+                    <cstring>unnamed</cstring>
+                </property>
+                <widget class="QCheckBox" row="1" column="0" rowspan="1" colspan="3">
+                    <property name="name">
+                        <cstring>cbUseEncryption</cstring>
+                    </property>
+                    <property name="enabled">
+                        <bool>false</bool>
+                    </property>
+                    <property name="text">
+                        <string>&amp;Enable encryption (secure, but slow and not always possible)</string>
+                    </property>
+                    <property name="whatsThis" stdset="0">
+                        <string>Enable this option to encrypt the connection. Only newer servers support this option. Encrypting prevents others from eavesdropping, but can slow down the connection considerably.</string>
+                    </property>
+                </widget>
+		<widget class="QCheckBox" row="2" column="0" rowspan="1" colspan="3">
+			<property name="name">
+				<cstring>cbUseKWallet</cstring>
+			</property>
+			<property name="enabled">
+				<bool>true</bool>
+			</property>
+			<property name="text">
+				<string>Use K&amp;Wallet for passwords</string>
+			</property>
+			<property name="whatsThis" stdset="0">
+				<string>Enable this option to store your passwords with KWallet.</string>
+			</property>
+		</widget>
+                <widget class="QLabel" row="0" column="0">
+                    <property name="name">
+                        <cstring>connectionTypeLabel</cstring>
+                    </property>
+                    <property name="sizePolicy">
+                        <sizepolicy>
+                            <hsizetype>0</hsizetype>
+                            <vsizetype>1</vsizetype>
+                            <horstretch>0</horstretch>
+                            <verstretch>0</verstretch>
+                        </sizepolicy>
+                    </property>
+                    <property name="text">
+                        <string>Connection &amp;type:</string>
+                    </property>
+                    <property name="buddy" stdset="0">
+                        <cstring>cmbQuality</cstring>
+                    </property>
+                </widget>
+                <widget class="QComboBox" row="0" column="1">
+                    <item>
+                        <property name="text">
+                            <string>High Quality (LAN, direct connection)</string>
+                        </property>
+                    </item>
+                    <item>
+                        <property name="text">
+                            <string>Medium Quality (DSL, Cable, fast Internet)</string>
+                        </property>
+                    </item>
+                    <item>
+                        <property name="text">
+                            <string>Low Quality (Modem, ISDN, slow Internet)</string>
+                        </property>
+                    </item>
+                    <property name="name">
+                        <cstring>cmbQuality</cstring>
+                    </property>
+                    <property name="sizePolicy">
+                        <sizepolicy>
+                            <hsizetype>5</hsizetype>
+                            <vsizetype>0</vsizetype>
+                            <horstretch>0</horstretch>
+                            <verstretch>0</verstretch>
+                        </sizepolicy>
+                    </property>
+                    <property name="minimumSize">
+                        <size>
+                            <width>280</width>
+                            <height>0</height>
+                        </size>
+                    </property>
+                    <property name="whatsThis" stdset="0">
+                        <string>Use this to specify the performance of your connection. Note that you should select the speed of the weakest link - even if you have a high speed connection, it will not help you if the remote computer uses a slow modem. Choosing a level of quality that is too high on a slow link will cause slower response times. Choosing a lower quality will increase latencies in high speed connections and results in lower image quality, especially in 'Low Quality' mode.</string>
+                    </property>
+                </widget>
+                <spacer row="0" column="2">
+                    <property name="name">
+                        <cstring>Spacer</cstring>
+                    </property>
+                    <property name="orientation">
+                        <enum>Horizontal</enum>
+                    </property>
+                    <property name="sizeType">
+                        <enum>Expanding</enum>
+                    </property>
+                    <property name="sizeHint">
+                        <size>
+                            <width>84</width>
+                            <height>16</height>
+                        </size>
+                    </property>
+                </spacer>
+            </grid>
+        </widget>
+        <widget class="QCheckBox">
+            <property name="name">
+                <cstring>cbShowPrefs</cstring>
+            </property>
+            <property name="text">
+                <string>&amp;Show this dialog again for this host</string>
+            </property>
+            <property name="whatsThis" stdset="0">
+                <string>Select this option if you do not want to be asked for the settings when connecting to a host. For hosts with existing profiles these profiles will be taken. New hosts will be configured with the defaults.</string>
+            </property>
+        </widget>
+    </vbox>
+</widget>
+<includes>
+    <include location="global" impldecl="in implementation">kdialog.h</include>
+    <include location="local" impldecl="in implementation">vncprefs.ui.h</include>
+</includes>
+<functions>
+    <function specifier="non virtual">setQuality( int quality )</function>
+    <function specifier="non virtual" returnType="int">quality()</function>
+    <function specifier="non virtual">setShowPrefs( bool b )</function>
+    <function specifier="non virtual" returnType="int">showPrefs()</function>
+    <function specifier="non virtual">setUseEncryption( bool b )</function>
+    <function specifier="non virtual" returnType="bool">useEncryption()</function>
+    <function specifier="non virtual">setUseKWallet( bool b )</function>
+    <function specifier="non virtual" returnType="bool">useKWallet()</function>
+</functions>
+<layoutdefaults spacing="6" margin="11"/>
+<layoutfunctions spacing="KDialog::spacingHint" margin="KDialog::marginHint"/>
+</UI>
diff --git a/krdc/vnc/vncprefs.ui.h b/krdc/vnc/vncprefs.ui.h
new file mode 100644
index 00000000..a3438f05
--- /dev/null
+++ b/krdc/vnc/vncprefs.ui.h
@@ -0,0 +1,53 @@
+/****************************************************************************
+** ui.h extension file, included from the uic-generated form implementation.
+**
+** If you wish to add, delete or rename functions or slots use
+** Qt Designer which will update this file, preserving your code. Create an
+** init() function in place of a constructor, and a destroy() function in
+** place of a destructor.
+*****************************************************************************/
+
+void VncPrefs::setQuality( int quality )
+{
+  cmbQuality->setCurrentItem(quality);
+}
+
+
+int VncPrefs::quality()
+{
+  return cmbQuality->currentItem();
+}
+
+
+void VncPrefs::setShowPrefs( bool b )
+{
+  cbShowPrefs->setChecked(b);
+}
+
+
+int VncPrefs::showPrefs()
+{
+  return cbShowPrefs->isChecked();
+}
+
+
+void VncPrefs::setUseEncryption( bool b )
+{
+  cbUseEncryption->setChecked(b);
+}
+
+
+bool VncPrefs::useEncryption()
+{
+  return cbUseEncryption->isChecked();
+}
+
+void VncPrefs::setUseKWallet( bool b )
+{
+  cbUseKWallet->setChecked(b);
+}
+
+bool VncPrefs::useKWallet()
+{
+  return cbUseKWallet->isChecked();
+}
diff --git a/krdc/vnc/vnctypes.h b/krdc/vnc/vnctypes.h
new file mode 100644
index 00000000..15329ee2
--- /dev/null
+++ b/krdc/vnc/vnctypes.h
@@ -0,0 +1,73 @@
+/*
+ *  Copyright (C) 2002 Tim Jansen.  All Rights Reserved.
+ *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
+ *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+#ifndef VNCTYPES_H
+#define VNCTYPES_H
+
+#if(defined __cplusplus)
+extern "C"
+{
+#endif
+
+#include <X11/Xmd.h>
+
+
+typedef struct {
+  int shareDesktop; /* bool */
+  int viewOnly; /* bool */
+
+  const char* encodingsString;
+
+  int useBGR233; /* bool */
+  int nColours;
+  int useSharedColours; /* bool */
+  int requestedDepth;
+
+  int rawDelay;
+  int copyRectDelay;
+
+  int debug; /* bool */
+
+  int compressLevel;
+  int qualityLevel;
+  int dotCursor; /* bool */
+
+} AppData;
+
+
+enum InitStatus {
+  INIT_OK = 0,
+  INIT_NAME_RESOLUTION_FAILURE = 1,
+  INIT_PROTOCOL_FAILURE = 2,
+  INIT_CONNECTION_FAILED = 3,
+  INIT_AUTHENTICATION_FAILED = 4,
+  INIT_NO_SERVER = 5,
+  INIT_SERVER_BLOCKED = 6,
+  INIT_ABORTED = 7
+};
+
+
+#if(defined __cplusplus)
+}
+#endif
+
+#endif
diff --git a/krdc/vnc/vncviewer.h b/krdc/vnc/vncviewer.h
new file mode 100644
index 00000000..dcc66cde
--- /dev/null
+++ b/krdc/vnc/vncviewer.h
@@ -0,0 +1,186 @@
+#ifndef VNCVIEWER_H
+#define VNCVIEWER_H
+/*
+ *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
+ *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * vncviewer.h
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Shell.h>
+#include <X11/keysym.h>
+#include <X11/Xatom.h>
+#include <X11/Xmu/StdSel.h>
+#include "vnctypes.h" 
+
+#if(defined __cplusplus)
+extern "C"
+{
+#endif
+
+#include "rfbproto.h"
+
+extern int endianTest;
+
+#define Swap16IfLE(s) \
+    (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))
+
+#define Swap32IfLE(l) \
+    (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \
+			     (((l) & 0x00ff0000) >> 8)  | \
+			     (((l) & 0x0000ff00) << 8)  | \
+			     (((l) & 0x000000ff) << 24))  : (l))
+
+#define MAX_ENCODINGS 20
+
+
+/** kvncview.cpp **/
+
+extern AppData appData;
+
+extern Display* dpy;
+extern const char *vncServerHost;
+extern int vncServerPort;
+
+extern int isQuitFlagSet();
+extern int getPassword(char *passwd, int pwlen);
+extern void DrawScreenRegion(int x, int y, int width, int height);
+extern void DrawAnyScreenRegionX11Thread(int x, int y, int width, int height);
+extern void LockFramebuffer();
+extern void UnlockFramebuffer();
+extern void EnableClientCursor(int state);
+extern void beep();
+extern void newServerCut(char *bytes, int len);
+extern void postMouseEvent(int x, int y, int buttonMask);
+
+/** threads.cpp **/
+
+extern void queueIncrementalUpdateRequest();
+extern void announceIncrementalUpdateRequest();
+
+/* colour.c */
+
+extern unsigned long BGR233ToPixel[];
+
+extern Colormap cmap;
+extern Visual *vis;
+extern unsigned int visdepth, visbpp;
+
+extern void SetVisualAndCmap(void);
+
+/* desktop.c */
+
+extern Widget form, viewport, desktop;
+extern GC gc;
+extern GC srcGC, dstGC;
+extern Dimension dpyWidth, dpyHeight;
+
+extern void DesktopInit(Window win);
+extern void ToplevelInit(void);
+extern void SendRFBEvent(XEvent *event, String *params, Cardinal *num_params);
+extern void CopyDataToScreen(char *buf, int x, int y, int width, int height);
+extern void CopyDataFromScreen(char *buf, int x, int y, int width, int height);
+extern void FillRectangle8(CARD8, int x, int y, int width, int height);
+extern void FillRectangle16(CARD16, int x, int y, int width, int height);
+extern void FillRectangle32(CARD32, int x, int y, int width, int height);
+extern void CopyArea(int srcX, int srcY, int width, int height, int x, int y);
+extern void SyncScreenRegion(int x, int y, int width, int height);
+extern void SyncScreenRegionX11Thread(int x, int y, int width, int height);
+extern void drawCursor(void);
+extern void DrawCursorX11Thread(int x, int y);
+extern void undrawCursor(void);
+extern void getBoundingRectCursor(int cx, int cy, int _imageIndex,
+				  int *x, int *y, int *w, int *h);
+extern int rectsIntersect(int x, int y, int w, int h, 
+			  int x2, int y2, int w2, int h2);
+extern int rectContains(int outX, int outY, int outW, int outH, 
+			int inX, int inY, int inW, int inH);
+extern void rectsJoin(int *nx1, int *ny1, int *nw1, int *nh1, 
+		      int x2, int y2, int w2, int h2);
+extern void DrawZoomedScreenRegionX11Thread(Window win, int zwidth, 
+					    int zheight, 
+					    int x, int y, 
+					    int width, int height);
+extern void DrawScreenRegionX11Thread(Window win, int x, int y, 
+				      int width, int height);
+extern void Cleanup(void);
+extern XImage *CreateShmZoomImage(void);
+extern XImage *CreateShmImage(void);
+extern void ShmCleanup(void);
+extern void freeDesktopResources(void);
+
+/* rfbproto.c */
+
+extern int rfbsock;
+extern Bool canUseCoRRE;
+extern Bool canUseHextile;
+extern char *desktopName;
+extern rfbPixelFormat myFormat;
+extern rfbServerInitMsg si;
+
+extern int cursorX, cursorY;
+extern int imageIndex;
+typedef struct {
+  int set;
+  int w, h;
+  int hotX, hotY;
+  int len;
+  char *image;
+} PointerImage;
+extern PointerImage pointerImages[];
+
+extern int ConnectToRFBServer(const char *hostname, int port);
+extern enum InitStatus InitialiseRFBConnection(void);
+extern Bool SetFormatAndEncodings(void);
+extern Bool SendIncrementalFramebufferUpdateRequest(void);
+extern Bool SendFramebufferUpdateRequest(int x, int y, int w, int h,
+					 Bool incremental);
+extern Bool SendPointerEvent(int x, int y, int buttonMask);
+extern Bool SendKeyEvent(CARD32 key, Bool down);
+extern Bool SendClientCutText(const char *str, int len);
+extern Bool HandleRFBServerMessage(void);
+
+extern void PrintPixelFormat(rfbPixelFormat *format);
+extern void freeRFBProtoResources(void);
+extern void freeResources(void);
+
+/* sockets.c */
+
+extern Bool errorMessageOnReadFailure;
+
+extern Bool ReadFromRFBServer(char *out, unsigned int n);
+extern Bool WriteExact(int sock, const char *buf, int n);
+extern int ConnectToTcpAddr(unsigned int host, int port);
+
+extern int StringToIPAddr(const char *str, unsigned int *addr);
+extern void freeSocketsResources(void);
+
+#if(defined __cplusplus)
+}
+#endif
+#endif
diff --git a/krdc/vnc/zlib.c b/krdc/vnc/zlib.c
new file mode 100644
index 00000000..80c4eeea
--- /dev/null
+++ b/krdc/vnc/zlib.c
@@ -0,0 +1,157 @@
+/*
+ *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ *  This 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 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.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this software; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  USA.
+ */
+
+/*
+ * zlib.c - handle zlib encoding.
+ *
+ * This file shouldn't be compiled directly.  It is included multiple times by
+ * rfbproto.c, each time with a different definition of the macro BPP.  For
+ * each value of BPP, this file defines a function which handles an zlib
+ * encoded rectangle with BPP bits per pixel.
+ */
+
+#define HandleZlibBPP CONCAT2E(HandleZlib,BPP)
+#define CARDBPP CONCAT2E(CARD,BPP)
+
+static Bool
+HandleZlibBPP (int rx, int ry, int rw, int rh)
+{
+  rfbZlibHeader hdr;
+  int remaining;
+  int inflateResult;
+  int toRead;
+
+  /* First make sure we have a large enough raw buffer to hold the
+   * decompressed data.  In practice, with a fixed BPP, fixed frame
+   * buffer size and the first update containing the entire frame
+   * buffer, this buffer allocation should only happen once, on the
+   * first update.
+   */
+  if ( raw_buffer_size < (( rw * rh ) * ( BPP / 8 ))) {
+
+    if ( raw_buffer != NULL ) {
+
+      free( raw_buffer );
+
+    }
+
+    raw_buffer_size = (( rw * rh ) * ( BPP / 8 ));
+    raw_buffer = (char*) malloc( raw_buffer_size );
+
+  }
+
+  if (!ReadFromRFBServer((char *)&hdr, sz_rfbZlibHeader))
+    return False;
+
+  remaining = Swap32IfLE(hdr.nBytes);
+
+  /* Need to initialize the decompressor state. */
+  decompStream.next_in   = ( Bytef * )buffer;
+  decompStream.avail_in  = 0;
+  decompStream.next_out  = ( Bytef * )raw_buffer;
+  decompStream.avail_out = raw_buffer_size;
+  decompStream.data_type = Z_BINARY;
+
+  /* Initialize the decompression stream structures on the first invocation. */
+  if ( decompStreamInited == False ) {
+
+    inflateResult = inflateInit( &decompStream );
+
+    if ( inflateResult != Z_OK ) {
+      fprintf(stderr,
+              "inflateInit returned error: %d, msg: %s\n",
+              inflateResult,
+              decompStream.msg);
+      return False;
+    }
+
+    decompStreamInited = True;
+
+  }
+
+  inflateResult = Z_OK;
+
+  /* Process buffer full of data until no more to process, or
+   * some type of inflater error, or Z_STREAM_END.
+   */
+  while (( remaining > 0 ) &&
+         ( inflateResult == Z_OK )) {
+  
+    if ( remaining > BUFFER_SIZE ) {
+      toRead = BUFFER_SIZE;
+    }
+    else {
+      toRead = remaining;
+    }
+
+    /* Fill the buffer, obtaining data from the server. */
+    if (!ReadFromRFBServer(buffer,toRead))
+      return False;
+
+    decompStream.next_in  = ( Bytef * )buffer;
+    decompStream.avail_in = toRead;
+
+    /* Need to uncompress buffer full. */
+    inflateResult = inflate( &decompStream, Z_SYNC_FLUSH );
+
+    /* We never supply a dictionary for compression. */
+    if ( inflateResult == Z_NEED_DICT ) {
+      fprintf(stderr,"zlib inflate needs a dictionary!\n");
+      return False;
+    }
+    if ( inflateResult < 0 ) {
+      fprintf(stderr,
+              "zlib inflate returned error: %d, msg: %s\n",
+              inflateResult,
+              decompStream.msg);
+      return False;
+    }
+
+    /* Result buffer allocated to be at least large enough.  We should
+     * never run out of space!
+     */
+    if (( decompStream.avail_in > 0 ) &&
+        ( decompStream.avail_out <= 0 )) {
+      fprintf(stderr,"zlib inflate ran out of space!\n");
+      return False;
+    }
+
+    remaining -= toRead;
+
+  } /* while ( remaining > 0 ) */
+
+  if ( inflateResult == Z_OK ) {
+
+    /* Put the uncompressed contents of the update on the screen. */
+    CopyDataToScreen(raw_buffer, rx, ry, rw, rh);
+
+  }
+  else {
+
+    fprintf(stderr,
+            "zlib inflate returned error: %d, msg: %s\n",
+            inflateResult,
+            decompStream.msg);
+    return False;
+
+  }
+
+  return True;
+}