Attachment #3074 for bug #3206

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 3206
Collapse All | Expand All

Lines 16-23 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/CMakeLists.txt (-2 lines)
16	include_directories(	16	include_directories(
17	${CMAKE_CURRENT_BINARY_DIR}	17	${CMAKE_CURRENT_BINARY_DIR}
18	${CMAKE_CURRENT_SOURCE_DIR}	18	${CMAKE_CURRENT_SOURCE_DIR}
19	${CMAKE_CURRENT_SOURCE_DIR}/../libtdevnc
20	${CMAKE_CURRENT_BINARY_DIR}/../libtdevnc
21	${CMAKE_BINARY_DIR}	19	${CMAKE_BINARY_DIR}
22	${TDE_INCLUDE_DIR}	20	${TDE_INCLUDE_DIR}
23	${TQT_INCLUDE_DIRS}	21	${TQT_INCLUDE_DIRS}

Lines 2-9 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/kremoteview.h (-2 lines)
2	kremoteview.h - widget that shows the remote framebuffer	2	kremoteview.h - widget that shows the remote framebuffer
3	-------------------	3	-------------------
4	begin : Wed Dec 25 23:58:12 CET 2002	4	begin : Wed Dec 25 23:58:12 CET 2002
5	copyright : (C) 2015 by Timothy Pearson
6	copyright : (C) 2007 by Urs Wolfer
7	copyright : (C) 2002-2003 by Tim Jansen	5	copyright : (C) 2002-2003 by Tim Jansen
8	email : tim@tjansen.de	6	email : tim@tjansen.de
9	***************************************************************************/	7	***************************************************************************/

Lines 24-30 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/Makefile.am (-1 / +1 lines)
24	dnssddata_DATA = _rfb._tcp	24	dnssddata_DATA = _rfb._tcp
25		25
26	krdc_LDADD = vnc/libvnc.la rdp/librdp.la $(LIB_TDEUI) $(LIBXF86VIDMODE) $(LIB_SLP) $(LIB_TDEDNSSD) $(X_LDFLAGS) $(LIB_X11) -ltdewalletclient -lDCOP	26	krdc_LDADD = vnc/libvnc.la rdp/librdp.la $(LIB_TDEUI) $(LIBXF86VIDMODE) $(LIB_SLP) $(LIB_TDEDNSSD) $(X_LDFLAGS) $(LIB_X11) -ltdewalletclient -lDCOP
27	krdc_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_TQT) -lDCOP $(LIB_TDECORE)	27	krdc_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_TDECORE)
28		28
29	xdg_apps_DATA = krdc.desktop	29	xdg_apps_DATA = krdc.desktop
30		30

Lines 8-11 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/rdp/Makefile.am (-1 / +1 lines)
8		8
9	noinst_HEADERS = krdpview.h rdphostpref.h	9	noinst_HEADERS = krdpview.h rdphostpref.h
10	librdp_la_LIBADD = $(LIB_TDEUI) $(LIBJPEG)	10	librdp_la_LIBADD = $(LIB_TDEUI) $(LIBJPEG)
11	librdp_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_TQT) -lDCOP $(LIB_TDECORE) $(LIB_TDEUI) -ltdefx $(LIB_TDEIO) -ltdetexteditor	11	librdp_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_TDECORE) $(LIB_TDEUI) -ltdefx $(LIB_TDEIO) -ltdetexteditor




#################################################
#
#  (C) 2015 Timothy Pearson
#  kb9vqf (AT) pearsoncomputing (DOT) net
#
#  (C) 2010-2011 Serghei Amelian
#  serghei (DOT) amelian (AT) gmail.com
#

  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/..
  ${CMAKE_CURRENT_SOURCE_DIR}/../../libtdevnc
  ${CMAKE_CURRENT_BINARY_DIR}/../../libtdevnc
  ${CMAKE_BINARY_DIR}
  ${TDE_INCLUDE_DIR}
  ${TQT_INCLUDE_DIRS}
)


tde_add_library( vnc STATIC_PIC AUTOMOC
  SOURCES
    kvncview.cpp threads.cpp colour.c d3des.c desktop.c rfbproto.c sockets.c
    vncauth.c vncprefs.ui vnchostpref.cpp
  LINK
    tdevncclient-static
)




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;
}




/*
 * 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
 **********************************************************************/




/*
 * 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
 ********************************************************************/




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;
  }
}
*/





/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;
}




                          kvncview.cpp  -  main widget
                             -------------------
    begin                : Thu Dec 20 15:11:42 CET 2001
    copyright            : (C) 2001-2003 by Tim Jansen
                           (C) 2001-2003 by Tim Jansen
    email                : tim@tjansen.de
 ***************************************************************************/


#include <tqbitmap.h>
#include <tqmutex.h>
#include <tqvbox.h>
#include <tqtimer.h>
#include <tqpainter.h>
#include <tqwaitcondition.h>

#include "vncviewer.h"

 * application resource specs.  The AppData structure is defined in the header
 * file.
 */
AppData appData;
bool appDataConfigured = false;

Display* dpy;

		   DotCursorState dotCursorState,
		   const TQString &encodings) :
  KRemoteView(parent, name, TQt::WResizeNoErase | TQt::WRepaintNoErase | TQt::WStaticContents),
  m_cthread(this, m_wthread, m_quitFlag),
  m_wthread(this, m_quitFlag),
  m_quitFlag(false),
  m_enableFramebufferLocking(false),
  m_scaling(false),


void KVncView::startQuitting() {
	m_quitFlag = true;
	m_wthread.kick();
	m_cthread.kick();
}

bool KVncView::isQuitting() {


void KVncView::configureApp(Quality q, const TQString 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() {


	setStatus(REMOTE_VIEW_CONNECTING);

	m_cthreadObject.moveToThread(&m_cthread);
	TQTimer::singleShot(0, &m_cthreadObject, SLOT(run()));
	m_cthread.start();

	setBackgroundMode(TQt::NoBackground);
	return true;
}

{
	startQuitting();
	m_cthread.wait();
	m_wthread.wait();
	freeResources();
}

bool KVncView::supportsLocalCursor() const {

			setMaximumSize(m_framebufferSize);
			setMinimumSize(m_framebufferSize.width()/16,
				       m_framebufferSize.height()/16);

			m_cthreadObject.setScaling(width(), height());
		}
		else
			setFixedSize(m_framebufferSize);
			m_cthreadObject.setScaling(-1, -1);
		}

		// Force full redraw
		drawRegion(0, 0, width(), height());
	}
}


		   e->rect().height());
}

void KVncView::resizeEvent(TQResizeEvent *e) {
	if (m_scaling) {
		m_cthreadObject.setScaling(width(), height());

		// Force full redraw
		drawRegion(0, 0, width(), 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(TQCustomEvent *e)

		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());

				wallet->setFolder(krdc_folder);
				TQString newPass;
				if ( wallet->hasEntry(kvncview->host()) && !wallet->readPassword(kvncview->host(), newPass) ) {
					password=newPass.latin1();
				}
			}
		}

		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
		// How to draw soft cursor?
		// DrawCursorX11Thread(x, y); // in rfbproto.c
	}
}

void KVncView::mousePressEvent(TQMouseEvent *e) {

		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();
}


	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();
}

			else
				unpressModifiers();
		}
		m_wthread.queueKeyEvent(s, pressed);
	}
	return true;
}

	TQValueList<unsigned int> keys = m_mods.keys();
	TQValueList<unsigned int>::const_iterator it = keys.begin();
	while (it != keys.end()) {
		m_wthread.queueKeyEvent(*it, false);
		it++;
	}
	m_mods.clear();

	if (text.length() > MAX_SELECTION_LENGTH)
		return;

	m_wthread.queueClientCut(text);
}

void KVncView::selectionChanged() {

	if (text.length() > MAX_SELECTION_LENGTH)
		return;

	m_wthread.queueClientCut(text);
}



	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


	//Process the password if we got it, clear it if we didn't
	if (retV) {
		strncpy(passwd, password.utf8(), pwlen);
	} else {
		passwd[0] = 0;
	}

	//Pack up and go home




                  kvncview.h  -  widget that shows the vnc client
                             -------------------
    begin                : Thu Dec 20 15:11:42 CET 2001
    copyright            : (C) 2001-2003 by Tim Jansen
                           (C) 2001-2003 by Tim Jansen
    email                : tim@tjansen.de
 ***************************************************************************/



#include "pointerlatencyometer.h"
#include "hostpreferences.h"
#include "vnctypes.h"
#include "threads.h"

class TQClipBoard;

	TQ_OBJECT
  
private:
	ControllerThread m_cthread;
	WriterThread m_wthread;
	volatile bool m_quitFlag; // if set: all threads should die ASAP
	TQMutex m_framebufferLock;
	bool m_enableFramebufferLocking;

	void mouseMoveEvent(TQMouseEvent*);
	void wheelEvent(TQWheelEvent *);
	void focusOutEvent(TQFocusEvent *);
	void resizeEvent(TQResizeEvent *);
	bool x11Event(XEvent*);

public:



private slots:
// 	void requestPassword();

	void clipboardChanged();
	void selectionChanged();
};




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;

  memset(&ke, 0, sizeof(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;

  memset(&cct, 0, sizeof(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;
  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
      lockTQt();
      XStoreColor(dpy, cmap, &xc);
      unlockTQt();
      */
    }

    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;
	/* RealVNC 4.x-5.x on OSX can induce bytesPerLine==0,
	   usually during GPU accel. */
	/* Regardless of cause, do not divide by zero. */
	linesToRead = bytesPerLine ? (BUFFER_SIZE / bytesPerLine) : 0;

	while (linesToRead && 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)) {
      free(serverCutText);
      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;
}





/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;




/****************************************************************************
**
** Copyright (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>
**
** This file is part of TDE.
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; see the file COPYING. If not, write to
** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
** Boston, MA 02110-1301, USA.
**
****************************************************************************/

#include <tqimage.h>

/*!

    Smooth scaling function with ability to limit scaled region
    The selection rectangle is given in terms of destination coordinates
    It leaves areas outside of the selection rectangle undefined...

    Function code originally taken from qimage.cpp pnmscale () and modified
    to only scale a section of the source

    This function uses code based on pnmscale.c by Jef Poskanzer.

    pnmscale.c - read a portable anymap and scale it

    \legalese

    Copyright (C) 1989, 1991 by Jef Poskanzer.

    Permission to use, copy, modify, and distribute this software and
    its documentation for any purpose and without fee is hereby
    granted, provided that the above copyright notice appear in all
    copies and that both that copyright notice and this permission
    notice appear in supporting documentation. This software is
    provided "as is" without express or implied warranty.

*/

void pnmscale_fractional(const TQImage& src, TQImage& dst, int x, int y, int w, int h)
{
    TQRgb* xelrow = 0;
    TQRgb* tempxelrow = 0;
    TQRgb* xP;
    TQRgb* nxP;
    int rows, cols, rowsread, newrows, newcols;
    int row, col, needtoreadrow;
    const uchar maxval = 255;
    double xscale, yscale;
    long sxscale, syscale;
    long fracrowtofill, fracrowleft;
    long* as;
    long* rs;
    long* gs;
    long* bs;
    int rowswritten = 0;
    int colswritten = 0;

    cols = src.width();
    rows = src.height();
    newcols = dst.width();
    newrows = dst.height();

    long SCALE;
    long HALFSCALE;

    if (cols > 4096)
    {
        SCALE = 4096;
        HALFSCALE = 2048;
    }
    else
    {
        int fac = 4096;

        while (cols * fac > 4096)
        {
            fac /= 2;
        }

        SCALE = fac * cols;
        HALFSCALE = fac * cols / 2;
    }

    xscale = (double) newcols / (double) cols;
    yscale = (double) newrows / (double) rows;

    sxscale = (long)(xscale * SCALE);
    syscale = (long)(yscale * SCALE);

    if ( newrows != rows )	/* shortcut Y scaling if possible */
	tempxelrow = new TQRgb[cols];

    if ( src.hasAlphaBuffer() ) {
	dst.setAlphaBuffer(TRUE);
	as = new long[cols];
	for ( col = 0; col < cols; ++col )
	    as[col] = HALFSCALE;
    } else {
	as = 0;
    }
    rs = new long[cols];
    gs = new long[cols];
    bs = new long[cols];
    rowsread = 0;
    fracrowleft = syscale;
    needtoreadrow = 1;
    for ( col = 0; col < cols; ++col )
	rs[col] = gs[col] = bs[col] = HALFSCALE;
    fracrowtofill = SCALE;

    for ( row = 0; row < newrows; ++row ) {
	/* First scale Y from xelrow into tempxelrow. */
	if ( newrows == rows ) {
	    /* shortcut Y scaling if possible */
	    tempxelrow = xelrow = (TQRgb*)src.scanLine(rowsread++);
	} else {
	    while ( fracrowleft < fracrowtofill ) {
		if ( needtoreadrow && rowsread < rows )
		    xelrow = (TQRgb*)src.scanLine(rowsread++);
		for ( col = 0, xP = xelrow; col < cols; ++col, ++xP ) {
if ((rowswritten >= y) && (rowswritten <= (y + h))) {
		    if (as) {
			as[col] += fracrowleft * tqAlpha( *xP );
			rs[col] += fracrowleft * tqRed( *xP ) * tqAlpha( *xP ) / 255;
			gs[col] += fracrowleft * tqGreen( *xP ) * tqAlpha( *xP ) / 255;
			bs[col] += fracrowleft * tqBlue( *xP ) * tqAlpha( *xP ) / 255;
		    } else {
			rs[col] += fracrowleft * tqRed( *xP );
			gs[col] += fracrowleft * tqGreen( *xP );
			bs[col] += fracrowleft * tqBlue( *xP );
		    }
}
		}
		fracrowtofill -= fracrowleft;
		fracrowleft = syscale;
		needtoreadrow = 1;
	    }
	    /* Now fracrowleft is >= fracrowtofill, so we can produce a row. */
	    if ( needtoreadrow && rowsread < rows ) {
		xelrow = (TQRgb*)src.scanLine(rowsread++);
		needtoreadrow = 0;
	    }
	    long a=0;
	    for ( col = 0, xP = xelrow, nxP = tempxelrow, colswritten = 0;
		  col < cols; ++col, ++xP, ++nxP, ++colswritten )
	    {
if ((rowswritten >= y) && (rowswritten <= (y + h))) {
		long r, g, b;

		if ( as ) {
		    r = rs[col] + fracrowtofill * tqRed( *xP ) * tqAlpha( *xP ) / 255;
		    g = gs[col] + fracrowtofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255;
		    b = bs[col] + fracrowtofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255;
		    a = as[col] + fracrowtofill * tqAlpha( *xP );
		    if ( a ) {
			r = r * 255 / a * SCALE;
			g = g * 255 / a * SCALE;
			b = b * 255 / a * SCALE;
		    }
		} else {
		    r = rs[col] + fracrowtofill * tqRed( *xP );
		    g = gs[col] + fracrowtofill * tqGreen( *xP );
		    b = bs[col] + fracrowtofill * tqBlue( *xP );
		}
		r /= SCALE;
		if ( r > maxval ) r = maxval;
		g /= SCALE;
		if ( g > maxval ) g = maxval;
		b /= SCALE;
		if ( b > maxval ) b = maxval;
		if ( as ) {
		    a /= SCALE;
		    if ( a > maxval ) a = maxval;
		    *nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
		    as[col] = HALFSCALE;
		} else {
		    *nxP = tqRgb( (int)r, (int)g, (int)b );
		}
		rs[col] = gs[col] = bs[col] = HALFSCALE;
}
	    }
	    fracrowleft -= fracrowtofill;
	    if ( fracrowleft == 0 ) {
		fracrowleft = syscale;
		needtoreadrow = 1;
	    }
	    fracrowtofill = SCALE;
	}

	/* Now scale X from tempxelrow into dst and write it out. */
	if ( newcols == cols ) {
	    /* shortcut X scaling if possible */
	    memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
	} else {
	    long a, r, g, b;
	    long fraccoltofill, fraccolleft = 0;
	    int needcol;

	    nxP = (TQRgb*)dst.scanLine(rowswritten++);
	    colswritten = 0;
	    fraccoltofill = SCALE;
	    a = r = g = b = HALFSCALE;
	    needcol = 0;
	    for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP ) {
		fraccolleft = sxscale;
		while ( fraccolleft >= fraccoltofill ) {
		    if ( needcol ) {
			++nxP;
			++colswritten;
			a = r = g = b = HALFSCALE;
		    }
if ((colswritten >= x) && (colswritten <= (x + w)) && (rowswritten >= y) && (rowswritten <= (y + h))) {
		    if ( as ) {
			r += fraccoltofill * tqRed( *xP ) * tqAlpha( *xP ) / 255;
			g += fraccoltofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255;
			b += fraccoltofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255;
			a += fraccoltofill * tqAlpha( *xP );
			if ( a ) {
			    r = r * 255 / a * SCALE;
			    g = g * 255 / a * SCALE;
			    b = b * 255 / a * SCALE;
			}
		    } else {
			r += fraccoltofill * tqRed( *xP );
			g += fraccoltofill * tqGreen( *xP );
			b += fraccoltofill * tqBlue( *xP );
		    }
		    r /= SCALE;
		    if ( r > maxval ) r = maxval;
		    g /= SCALE;
		    if ( g > maxval ) g = maxval;
		    b /= SCALE;
		    if ( b > maxval ) b = maxval;
		    if (as) {
			a /= SCALE;
			if ( a > maxval ) a = maxval;
			*nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
		    } else {
			*nxP = tqRgb( (int)r, (int)g, (int)b );
		    }
}
		    fraccolleft -= fraccoltofill;
		    fraccoltofill = SCALE;
		    needcol = 1;
		}
		if ( fraccolleft > 0 ) {
		    if ( needcol ) {
			++nxP;
			++colswritten;
			a = r = g = b = HALFSCALE;
			needcol = 0;
		    }
if ((rowswritten >= y) && (rowswritten <= (y + h))) {
		    if (as) {
			a += fraccolleft * tqAlpha( *xP );
			r += fraccolleft * tqRed( *xP ) * tqAlpha( *xP ) / 255;
			g += fraccolleft * tqGreen( *xP ) * tqAlpha( *xP ) / 255;
			b += fraccolleft * tqBlue( *xP ) * tqAlpha( *xP ) / 255;
		    } else {
			r += fraccolleft * tqRed( *xP );
			g += fraccolleft * tqGreen( *xP );
			b += fraccolleft * tqBlue( *xP );
		    }
}
		    fraccoltofill -= fraccolleft;
		}
	    }
	    if ( fraccoltofill > 0 ) {
		--xP;
if ((rowswritten >= y) && (rowswritten <= (y + h))) {
		if (as) {
		    a += fraccolleft * tqAlpha( *xP );
		    r += fraccoltofill * tqRed( *xP ) * tqAlpha( *xP ) / 255;
		    g += fraccoltofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255;
		    b += fraccoltofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255;
		    if ( a ) {
			r = r * 255 / a * SCALE;
			g = g * 255 / a * SCALE;
			b = b * 255 / a * SCALE;
		    }
		} else {
		    r += fraccoltofill * tqRed( *xP );
		    g += fraccoltofill * tqGreen( *xP );
		    b += fraccoltofill * tqBlue( *xP );
		}
}
	    }
	    if ( ! needcol ) {
if ((rowswritten >= y) && (rowswritten <= (y + h))) {
		r /= SCALE;
		if ( r > maxval ) r = maxval;
		g /= SCALE;
		if ( g > maxval ) g = maxval;
		b /= SCALE;
		if ( b > maxval ) b = maxval;
		if (as) {
		    a /= SCALE;
		    if ( a > maxval ) a = maxval;
		    *nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
		} else {
		    *nxP = tqRgb( (int)r, (int)g, (int)b );
		}
}
	    }
	}
    }

    if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
	delete [] tempxelrow;
    if ( as )				// Avoid purify complaint
	delete [] as;
    if ( rs )				// Robust, rs might be 0 one day
	delete [] rs;
    if ( gs )				// Robust, gs might be 0 one day
	delete [] gs;
    if ( bs )				// Robust, bs might be 0 one day
	delete [] bs;
}




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;
}


Lines 2-9 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.cpp (-299 / +307 lines)
2	threads.cpp - threads	2	threads.cpp - threads
3	-------------------	3	-------------------
4	begin : Thu May 09 17:01:44 CET 2002	4	begin : Thu May 09 17:01:44 CET 2002
5	copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>	5	copyright : (C) 2002 by Tim Jansen
6	(C) 2002 by Tim Jansen
7	email : tim@tjansen.de	6	email : tim@tjansen.de
8	***************************************************************************/	7	***************************************************************************/
9		8
Lines 25-384 Link Here
25	#include "threads.h"	24	#include "threads.h"
26		25
27	#include <tqcstring.h>	26	#include <tqcstring.h>
28	#include <tqpainter.h>
29		27
30	#include <math.h>	28	// Maximum idle time for writer thread in ms. When it timeouts, it will request
		29	// another incremental update. Must be smaller than the timeout of the server
		30	// (krfb's is 20s).
		31	static const int MAXIMUM_WAIT_PERIOD = 8000;
31		32
32	extern void pnmscale_fractional(const TQImage& src, TQImage& dst, int x, int y, int w, int h);	33	// time to postpone incremental updates that have not been requested explicitly
		34	static const int POSTPONED_INCRRQ_WAIT_PERIOD = 110;
33		35
34	int getPassword(char * &passwd);	36	static const int MOUSEPRESS_QUEUE_SIZE = 5;
		37	static const int MOUSEMOVE_QUEUE_SIZE = 3;
		38	static const int KEY_QUEUE_SIZE = 8192;
35		39
36	extern rfbBool newclient(rfbClient *cl)
37	{
38	int width = cl->width, height = cl->height, depth = cl->format.bitsPerPixel;
39	int size = width * height * (depth / 8);
40	uint8_t *buf = new uint8_t[size];
41	memset(buf, '\0', size);
42	cl->frameBuffer = buf;
43	cl->format.bitsPerPixel = 32;
44	cl->format.redShift = 16;
45	cl->format.greenShift = 8;
46	cl->format.blueShift = 0;
47	cl->format.redMax = 0xff;
48	cl->format.greenMax = 0xff;
49	cl->format.blueMax = 0xff;
50
51	SetFormatAndEncodings(cl);
52
53	return true;
54	}
55
56	extern void updatefb(rfbClient* cl, int x, int y, int w, int h)
57	{
58	// kdDebug(5011) << "updated client: x: " << x << ", y: " << y << ", w: " << w << ", h: " << h << endl;
59
60	int width = cl->width, height = cl->height;
61
62	TQImage img(cl->frameBuffer, width, height, 32, NULL, 256, TQImage::IgnoreEndian);
63
64	if (img.isNull())
65	kdDebug(5011) << "image not loaded" << endl;
66
67
68	ControllerThreadObject t = (ControllerThreadObject)rfbClientGetClientData(cl, 0);
69
70	t->setImage(img);
71	t->queueDrawRegion(x, y, w, h);
72	}
73
74	extern char passwd(rfbClient cl)
75	{
76	Q_UNUSED(cl)
77		40
78	kdDebug(5011) << "password request" << endl;	41	ControllerThread::ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag) :
79
80	char *passwd;
81	if (getPassword(passwd)) {
82	return passwd;
83	}
84	else {
85	return NULL;
86	}
87	}
88
89	extern void authresults(rfbClient *cl, uint32_t authResult)
90	{
91	kdDebug(5011) << "authentication result: " << authResult << endl;
92
93	ControllerThreadObject t = (ControllerThreadObject)rfbClientGetClientData(cl, 0);
94
95	t->authenticationResults(authResult);
96	}
97
98	extern void networkstat(rfbClient *cl, uint32_t statuscode)
99	{
100	kdDebug(5011) << "network status: " << statuscode << endl;
101
102	ControllerThreadObject t = (ControllerThreadObject)rfbClientGetClientData(cl, 0);
103
104	t->networkStatus(statuscode);
105	}
106
107	extern void output(const char *format, ...)
108	{
109	va_list args;
110	va_start(args, format);
111
112	TQString message;
113	message.vsprintf(format, args);
114
115	va_end(args);
116
117	kdDebug(5011) << message.local8Bit();
118
119	if (message.contains("Could not open")) {
120	kdDebug(5011) << "Server not found!" << endl;
121	}
122
123	if (message.contains("VNC authentication succeeded")) {
124	kdDebug(5011) << "Password OK" << endl;
125	}
126	}
127
128	ControllerThreadObject::ControllerThreadObject(KVncView *v, volatile bool &quitFlag) :
129	cl(0L),
130	m_view(v),	42	m_view(v),
131	m_status(REMOTE_VIEW_CONNECTING),	43	m_status(REMOTE_VIEW_CONNECTING),
		44	m_wthread(wt),
132	m_quitFlag(quitFlag),	45	m_quitFlag(quitFlag),
133	m_scaling(false),	46	m_desktopInitialized(false)
134	m_scalingWidth(-1),
135	m_scalingHeight(-1),
136	m_resizeEntireFrame(false)
137	{	47	{
138	TQMutexLocker locker(&mutex);
139
140	cl = rfbGetClient(8, 3, 4);
141	}	48	}
142		49
143	ControllerThreadObject::~ControllerThreadObject() {	50	void ControllerThread::changeStatus(RemoteViewStatus s) {
144	TQMutexLocker locker(&mutex);
145
146	rfbClientCleanup(cl);
147	}
148
149	void ControllerThreadObject::changeStatus(RemoteViewStatus s) {
150	m_status = s;	51	m_status = s;
151	TQApplication::postEvent(m_view, new StatusChangeEvent(s));	52	TQApplication::postEvent(m_view, new StatusChangeEvent(s));
152	}	53	}
153		54
154	void ControllerThreadObject::sendFatalError(ErrorCode s) {	55	void ControllerThread::sendFatalError(ErrorCode s) {
155	m_quitFlag = true;	56	m_quitFlag = true;
156	TQApplication::postEvent(m_view, new FatalErrorEvent(s));	57	TQApplication::postEvent(m_view, new FatalErrorEvent(s));
		58	m_wthread.kick();
157	}	59	}
158		60
159	void ControllerThreadObject::queueDrawRegion(int x, int y, int w, int h) {	61	/*
160	if (m_scaling) {	62	* Calls this from the X11 thread
161	// Rescale desktop	63	*/
		64	void ControllerThread::desktopInit() {
		65	SetVisualAndCmap();
		66	ToplevelInit();
		67	DesktopInit(m_view->winId());
		68	m_desktopInitialized = true;
		69	m_waiter.wakeAll();
		70	}
		71
		72	void ControllerThread::kick() {
		73	m_waiter.wakeAll();
		74	}
		75
		76	void ControllerThread::run() {
		77	int fd;
		78	fd = ConnectToRFBServer(m_view->host().latin1(), m_view->port());
		79	if (fd < 0) {
		80	if (fd == -(int)INIT_NO_SERVER)
		81	sendFatalError(ERROR_NO_SERVER);
		82	else if (fd == -(int)INIT_NAME_RESOLUTION_FAILURE)
		83	sendFatalError(ERROR_NAME);
		84	else
		85	sendFatalError(ERROR_CONNECTION);
		86	return;
		87	}
		88	if (m_quitFlag) {
		89	changeStatus(REMOTE_VIEW_DISCONNECTED);
		90	return;
		91	}
		92
		93	changeStatus(REMOTE_VIEW_AUTHENTICATING);
162		94
163	int new_x;	95	enum InitStatus s = InitialiseRFBConnection();
164	int new_y;	96	if (s != INIT_OK) {
165	int new_w;	97	if (s == INIT_CONNECTION_FAILED)
166	int new_h;	98	sendFatalError(ERROR_IO);
		99	else if (s == INIT_SERVER_BLOCKED)
		100	sendFatalError(ERROR_SERVER_BLOCKED);
		101	else if (s == INIT_PROTOCOL_FAILURE)
		102	sendFatalError(ERROR_PROTOCOL);
		103	else if (s == INIT_AUTHENTICATION_FAILED)
		104	sendFatalError(ERROR_AUTHENTICATION);
		105	else if (s == INIT_ABORTED)
		106	changeStatus(REMOTE_VIEW_DISCONNECTED);
		107	else
		108	sendFatalError(ERROR_INTERNAL);
		109	return;
		110	}
167		111
168	mutex.lock();	112	TQApplication::postEvent(m_view,
		113	new ScreenResizeEvent(si.framebufferWidth,
		114	si.framebufferHeight));
		115	m_wthread.queueUpdateRequest(TQRegion(TQRect(0,0,si.framebufferWidth,
		116	si.framebufferHeight)));
		117
		118	TQApplication::postEvent(m_view, new DesktopInitEvent());
		119	while ((!m_quitFlag) && (!m_desktopInitialized))
		120	m_waiter.wait(1000);
169		121
170	if (m_resizeEntireFrame) {	122	if (m_quitFlag) {
171	m_scaledImage.create(m_scalingWidth, m_scalingHeight, 32);	123	changeStatus(REMOTE_VIEW_DISCONNECTED);
		124	return;
		125	}
172		126
173	new_x = 0;	127	changeStatus(REMOTE_VIEW_PREPARING);
174	new_y = 0;
175	new_w = m_scalingWidth;
176	new_h = m_scalingHeight;
177		128
178	TQImage scaledBlock = m_image.smoothScale(new_w, new_h);	129	if (!SetFormatAndEncodings()) {
179	bitBlt(&m_scaledImage, new_x, new_y, &scaledBlock, 0, 0, new_w, new_h);	130	sendFatalError(ERROR_INTERNAL);
		131	return;
		132	}
180		133
181	m_resizeEntireFrame = false;	134	changeStatus(REMOTE_VIEW_CONNECTED);
182	}
183	else {
184	// Extend redraw boundaries to avoid pixelation artifacts due to rounding errors
185	x = x - round((2.0 * m_image.width()) / m_scalingWidth);
186	y = y - round((2.0 * m_image.height()) / m_scalingHeight);
187	w = w + round((4.0 * m_image.width()) / m_scalingWidth);
188	h = h + round((4.0 * m_image.height()) / m_scalingHeight);
189		135
190	if (x < 0) {	136	m_wthread.start();
191	x = 0;
192	}
193	if (y < 0) {
194	y = 0;
195	}
196	if (w > m_image.width()) {
197	w = m_image.width();
198	}
199	if (h > m_image.height()) {
200	h = m_image.height();
201	}
202		137
203	new_x = round((x * m_scalingWidth) / m_image.width());	138	while (!m_quitFlag) {
204	new_y = round((y * m_scalingHeight) / m_image.height());	139	if ((!HandleRFBServerMessage()) && (!m_quitFlag)) {
205	new_w = round((w * m_scalingWidth) / m_image.width());	140	sendFatalError(ERROR_IO);
206	new_h = round((h * m_scalingHeight) / m_image.height());	141	return;
207
208	TQImage scaledBlock(m_scalingWidth, m_scalingHeight, 32);
209	pnmscale_fractional(m_image, scaledBlock, new_x, new_y, new_w, new_h);
210	bitBlt(&m_scaledImage, new_x, new_y, &scaledBlock, new_x, new_y, new_w, new_h);
211	}	142	}
		143	}
212		144
213	mutex.unlock();	145	m_quitFlag = true;
		146	changeStatus(REMOTE_VIEW_DISCONNECTED);
		147	m_wthread.kick();
		148	}
214		149
215	DrawScreenRegion(new_x, new_y, new_w, new_h);	150	enum RemoteViewStatus ControllerThread::status() {
216	}	151	return m_status;
217	else {
218	DrawScreenRegion(x, y, w, h);
219	}
220	}	152	}
221		153
222	void ControllerThreadObject::setImage(const TQImage &img) {
223	TQMutexLocker locker(&mutex);
224		154
225	m_image = img;
226	}
227		155
228	const TQImage ControllerThreadObject::image(int x, int y, int w, int h) {
229	TQMutexLocker locker(&mutex);
230		156
231	if (m_scaling) {
232	return m_scaledImage.copy(x, y, w, h);
233	}
234	else {
235	return m_image.copy(x, y, w, h);
236	}
237	}
238		157
239	void ControllerThreadObject::setScaling(int w, int h) {	158	static WriterThread *writerThread;
240	bool scale;	159	void queueIncrementalUpdateRequest() {
		160	writerThread->queueIncrementalUpdateRequest();
		161	}
241		162
242	if (w <= 0) {	163	void announceIncrementalUpdateRequest() {
243	scale = false;	164	writerThread->announceIncrementalUpdateRequest();
244	}	165	}
245	else {
246	scale = true;
247	}
248		166
249	if ((m_scalingWidth != w) \|\| (m_scalingHeight = h) \|\| (m_scaling != scale)) {
250	m_resizeEntireFrame = true;
251	}
252		167
253	m_scaling = scale;	168	WriterThread::WriterThread(KVncView *v, volatile bool &quitFlag) :
254	m_scalingWidth = w;	169	m_quitFlag(quitFlag),
255	m_scalingHeight = h;	170	m_view(v),
256	}	171	m_lastIncrUpdatePostponed(false),
257		172	m_incrementalUpdateRQ(false),
258	void ControllerThreadObject::run() {	173	m_incrementalUpdateAnnounced(false),
259	mutex.lock();	174	m_mouseEventNum(0),
260		175	m_keyEventNum(0),
261	rfbClientLog = output;	176	m_clientCut(TQString())
262	rfbClientErr = output;	177	{
263	cl->MallocFrameBuffer = newclient;	178	writerThread = this;
264	cl->canHandleNewFBSize = true;	179	m_lastIncrUpdate.start();
265	cl->GetPassword = passwd;	180	}
266	cl->AuthenticationResults = authresults;
267	cl->NetworkStatus = networkstat;
268	cl->GotFrameBufferUpdate = updatefb;
269	rfbClientSetClientData(cl, 0, this);
270
271	// make a copy of the host string...
272	char host = (char) malloc(m_view->host().length());
273	strcpy(host, m_view->host().ascii());
274
275	cl->serverHost = host;
276
277	int port = m_view->port();
278	if(port >= 0 && port < 100) // the user most likely used the short form (e.g. :1)
279	port += 5900;
280	cl->serverPort = port;
281		181
282	mutex.unlock();	182	bool WriterThread::sendIncrementalUpdateRequest() {
		183	m_lastIncrUpdate.restart();
		184	return SendIncrementalFramebufferUpdateRequest();
		185	}
		186
		187	bool WriterThread::sendUpdateRequest(const TQRegion &region) {
		188	TQMemArray<TQRect> r = region.rects();
		189	for (unsigned int i = 0; i < r.size(); i++)
		190	if (!SendFramebufferUpdateRequest(r[i].x(),
		191	r[i].y(),
		192	r[i].width(),
		193	r[i].height(), False))
		194	return false;
		195	return true;
		196	}
283		197
284	if(!rfbInitClient(cl, 0, 0)) {	198	bool WriterThread::sendInputEvents(const TQValueList<InputEvent> &events) {
285	sendFatalError(ERROR_INTERNAL);	199	TQValueList<InputEvent>::const_iterator it = events.begin();
286	// Terminate thread	200	while (it != events.end()) {
287	TQThread::exit();	201	if ((*it).type == KeyEventType) {
288	return;	202	if (!SendKeyEvent((it).e.k.k, (it).e.k.down ? True : False))
		203	return false;
		204	}
		205	else
		206	if (!SendPointerEvent((it).e.m.x, (it).e.m.y, (*it).e.m.buttons))
		207	return false;
		208	it++;
289	}	209	}
		210	return true;
		211	}
290		212
291	TQApplication::postEvent(m_view,	213	void WriterThread::queueIncrementalUpdateRequest() {
292	new ScreenResizeEvent(cl->width,	214	m_lock.lock();
293	cl->height));	215	m_incrementalUpdateRQ = true;
		216	m_waiter.wakeAll();
		217	m_lock.unlock();
		218	}
		219
		220	void WriterThread::announceIncrementalUpdateRequest() {
		221	m_lock.lock();
		222	m_incrementalUpdateAnnounced = true;
		223	m_lock.unlock();
		224	}
294		225
295	changeStatus(REMOTE_VIEW_CONNECTED);
296
297	while (!m_quitFlag) {
298	int i = WaitForMessage(cl, 500);
299	if (i < 0) {
300	m_quitFlag = true;
301	changeStatus(REMOTE_VIEW_DISCONNECTED);
302		226
303	// Terminate thread	227	void WriterThread::queueUpdateRequest(const TQRegion &r) {
304	TQThread::exit();	228	m_lock.lock();
		229	m_updateRegionRQ += r;
		230	m_waiter.wakeAll();
		231	m_lock.unlock();
		232	}
		233
		234	void WriterThread::queueMouseEvent(int x, int y, int buttonMask) {
		235	InputEvent e;
		236	e.type = MouseEventType;
		237	e.e.m.x = x;
		238	e.e.m.y = y;
		239	e.e.m.buttons = buttonMask;
		240
		241	m_lock.lock();
		242	if (m_mouseEventNum > 0) {
		243	if ((e.e.m.x == m_lastMouseEvent.x) &&
		244	(e.e.m.y == m_lastMouseEvent.y) &&
		245	(e.e.m.buttons == m_lastMouseEvent.buttons)) {
		246	m_lock.unlock();
305	return;	247	return;
306	}	248	}
307	if (i) {	249	if (m_mouseEventNum >= MOUSEPRESS_QUEUE_SIZE) {
308	if(!HandleRFBServerMessage(cl)) {	250	m_lock.unlock();
309	m_quitFlag = true;	251	return;
310	changeStatus(REMOTE_VIEW_DISCONNECTED);	252	}
311		253	if ((m_lastMouseEvent.buttons == buttonMask) &&
312	// Terminate thread	254	(m_mouseEventNum >= MOUSEMOVE_QUEUE_SIZE)) {
313	TQThread::exit();	255	m_lock.unlock();
314	return;	256	return;
315	}
316	}	257	}
317	}	258	}
318		259
319	m_quitFlag = true;	260	m_mouseEventNum++;
320	changeStatus(REMOTE_VIEW_DISCONNECTED);	261	m_lastMouseEvent = e.e.m;
321
322	// Terminate thread
323	TQThread::exit();
324	}
325
326	void ControllerThreadObject::authenticationResults(int resultCode) {
327	if (resultCode == rfbVncAuthOK) {
328	changeStatus(REMOTE_VIEW_PREPARING);
329	}
330	else {
331	sendFatalError(ERROR_AUTHENTICATION);
332		262
333	// Terminate thread	263	m_inputEvents.push_back(e);
334	TQThread::exit();	264	m_waiter.wakeAll();
		265	m_lock.unlock();
		266	}
		267
		268	void WriterThread::queueKeyEvent(unsigned int k, bool down) {
		269	InputEvent e;
		270	e.type = KeyEventType;
		271	e.e.k.k = k;
		272	e.e.k.down = down;
		273
		274	m_lock.lock();
		275	if (m_keyEventNum >= KEY_QUEUE_SIZE) {
		276	m_lock.unlock();
		277	return;
335	}	278	}
336	}
337		279
338	void ControllerThreadObject::networkStatus(int statusCode) {	280	m_keyEventNum++;
339	if (statusCode == rfbNetworkConnectionSuccess) {	281	m_inputEvents.push_back(e);
340	// Stage 1 OK...	282	m_waiter.wakeAll();
341	changeStatus(REMOTE_VIEW_AUTHENTICATING);	283	m_lock.unlock();
342	}	284	}
343	else if (statusCode == rfbNetworkRFBConnectionSuccess) {	285
344	// Stage 2 OK!	286	void WriterThread::queueClientCut(const TQString &text) {
345	}	287	m_lock.lock();
346	else {	288
347	if (statusCode == rfbNetworkConnectionClosed) {	289	m_clientCut = text;
348	sendFatalError(ERROR_CONNECTION);	290
349	}	291	m_waiter.wakeAll();
350	else if (statusCode == rfbNetworkConnectionFailed) {	292	m_lock.unlock();
351	sendFatalError(ERROR_CONNECTION);	293	}
352	}	294
353	else if (statusCode == rfbNetworkNameResolutionFailed) {	295	void WriterThread::kick() {
354	sendFatalError(ERROR_NAME);	296	m_waiter.wakeAll();
355	}	297	}
356	else if (statusCode == rfbNetworkRFBServerNotValid) {	298
357	sendFatalError(ERROR_IO);	299	void WriterThread::run() {
		300	bool incrementalUpdateRQ = false;
		301	bool incrementalUpdateAnnounced = false;
		302	TQRegion updateRegionRQ;
		303	TQValueList<InputEvent> inputEvents;
		304	TQString clientCut;
		305
		306	while (!m_quitFlag) {
		307	m_lock.lock();
		308	incrementalUpdateRQ = m_incrementalUpdateRQ;
		309	incrementalUpdateAnnounced = m_incrementalUpdateAnnounced;
		310	updateRegionRQ = m_updateRegionRQ;
		311	inputEvents = m_inputEvents;
		312	clientCut = m_clientCut;
		313
		314	if ((!incrementalUpdateRQ) &&
		315	(updateRegionRQ.isNull()) &&
		316	(inputEvents.size() == 0) &&
		317	(clientCut.isNull())) {
		318	if (!m_waiter.wait(&m_lock,
		319	m_lastIncrUpdatePostponed ?
		320	POSTPONED_INCRRQ_WAIT_PERIOD : MAXIMUM_WAIT_PERIOD))
		321	m_incrementalUpdateRQ = true;
		322	m_lock.unlock();
358	}	323	}
359	else if (statusCode == rfbNetworkRFBProtocolFailure) {	324	else {
360	sendFatalError(ERROR_PROTOCOL);	325	m_incrementalUpdateRQ = false;
		326	m_incrementalUpdateAnnounced = false;
		327	m_updateRegionRQ = TQRegion();
		328	m_inputEvents.clear();
		329	m_keyEventNum = 0;
		330	m_mouseEventNum = 0;
		331	m_clientCut = TQString();
		332	m_lock.unlock();
		333
		334	// always send incremental update, unless
		335	// a) a framebuffer update is done ATM and will do the request later, or
		336	// b) the last unrequested update has been done less than 0.1s ago
		337	//
		338	// if the update has not been done because of b, postpone it.
		339	if (incrementalUpdateRQ \|\| !incrementalUpdateAnnounced) {
		340	bool sendUpdate;
		341	if (incrementalUpdateRQ) {
		342	sendUpdate = true;
		343	m_lastIncrUpdatePostponed = false;
		344	}
		345	else {
		346	if (m_lastIncrUpdate.elapsed() < 100) {
		347	sendUpdate = false;
		348	m_lastIncrUpdatePostponed = true;
		349	}
		350	else {
		351	sendUpdate = true;
		352	m_lastIncrUpdatePostponed = false;
		353	}
		354	}
		355
		356	if (sendUpdate)
		357	if (!sendIncrementalUpdateRequest()) {
		358	sendFatalError(ERROR_IO);
		359	break;
		360	}
		361	}
		362	else
		363	m_lastIncrUpdatePostponed = false;
		364
		365	if (!updateRegionRQ.isNull())
		366	if (!sendUpdateRequest(updateRegionRQ)) {
		367	sendFatalError(ERROR_IO);
		368	break;
		369	}
		370	if (inputEvents.size() != 0)
		371	if (!sendInputEvents(inputEvents)) {
		372	sendFatalError(ERROR_IO);
		373	break;
		374	}
		375	if (!clientCut.isNull()) {
		376	TQCString cutTextUtf8(clientCut.utf8());
		377	if (!SendClientCutText(cutTextUtf8.data(),
		378	(int)cutTextUtf8.length())) {
		379	sendFatalError(ERROR_IO);
		380	break;
		381	}
		382	}
361	}	383	}
362
363	// Terminate thread
364	TQThread::exit();
365	}	384	}
		385	m_quitFlag = true;
366	}	386	}
367		387
368	enum RemoteViewStatus ControllerThreadObject::status() {	388	void WriterThread::sendFatalError(ErrorCode s) {
369	return m_status;	389	m_quitFlag = true;
370	}	390	TQApplication::postEvent(m_view, new FatalErrorEvent(s));
371
372	void ControllerThreadObject::queueMouseEvent(int x, int y, int buttonMask) {
373	SendPointerEvent(cl, x, y, buttonMask);
374	}
375
376	void ControllerThreadObject::queueKeyEvent(unsigned int k, bool down) {
377	SendKeyEvent(cl, k, down);
378	}
379
380	void ControllerThreadObject::queueClientCut(const TQString &text) {
381	SendClientCutText(cl, (char*)text.ascii(), text.length());
382	}	391	}
383		392
384	#include "threads.moc"




                          threads.h  -  threads for kvncview
                             -------------------
    begin                : Thu May 09 16:01:42 CET 2002
    copyright            : (C) 2002 by Tim Jansen
                           (C) 2002 by Tim Jansen
    email                : tim@tjansen.de
 ***************************************************************************/


#include <tqevent.h>
#include <tqvaluelist.h>
#include <tqdatetime.h>
#include <tqimage.h>

#include <stdlib.h> 

#include "events.h"
#include "vnctypes.h"
extern "C" {
#include <rfb/rfbclient.h>
}

class KVncView;


	} e;
};

class ControllerThreadObject : public TQObject {
	TQ_OBJECT

	public:
		ControllerThreadObject(KVncView *v, volatile bool &quitFlag);
		~ControllerThreadObject();

		enum RemoteViewStatus status();	

class WriterThread : public TQThread {
private:
	TQMutex m_lock;
	TQWaitCondition m_waiter;
	volatile bool &m_quitFlag;
	KVncView *m_view;

	TQTime 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
	TQRegion m_updateRegionRQ;  // for sending updates, null if it is done
	TQValueList<InputEvent> m_inputEvents; // list of unsent input events
	MouseEvent m_lastMouseEvent;
	int m_mouseEventNum, m_keyEventNum;
	TQString m_clientCut;

	void sendFatalError(ErrorCode s);
		void queueDrawRegion(int x, int y, int w, int h);

public:
	WriterThread(KVncView *v, volatile bool &quitFlag);
	public slots:
		void run();
	
	public:
		void queueMouseEvent(int x, int y, int buttonMask);
		void queueKeyEvent(unsigned int k, bool down);
		void queueClientCut(const TQString &text);

	private:
		KVncView *m_view;
		TQImage m_image;
		TQImage m_scaledImage;
		TQMutex mutex;
		enum RemoteViewStatus m_status;
		volatile bool &m_quitFlag;

		bool m_scaling;
		int m_scalingWidth;
		int m_scalingHeight;
		bool m_resizeEntireFrame;
	
	void queueIncrementalUpdateRequest();
	void announceIncrementalUpdateRequest();
	void queueUpdateRequest(const TQRegion &r);
	void queueMouseEvent(int x, int y, int buttonMask);
	void queueKeyEvent(unsigned int k, bool down);
	void queueClientCut(const TQString &text);
	void kick();
	
protected:
	void run();
	bool sendIncrementalUpdateRequest();
	bool sendUpdateRequest(const TQRegion &r);
	bool sendInputEvents(const TQValueList<InputEvent> &events);
};



class ControllerThread : public TQThread { 
private:
	KVncView *m_view;
	enum RemoteViewStatus m_status;
	WriterThread &m_wthread;
	volatile bool &m_quitFlag;
	volatile bool m_desktopInitialized;
	TQWaitCondition 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();
};






/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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





/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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);
    }
}




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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);




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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




#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 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




/*
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *  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;
}

Return to bug 3206

Lines 1-8 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/CMakeLists.txt (-10 / +2 lines)
1	#################################################	1	#################################################
2	#	2	#
3	# (C) 2015 Timothy Pearson
4	# kb9vqf (AT) pearsoncomputing (DOT) net
5	#
6	# (C) 2010-2011 Serghei Amelian	3	# (C) 2010-2011 Serghei Amelian
7	# serghei (DOT) amelian (AT) gmail.com	4	# serghei (DOT) amelian (AT) gmail.com
8	#	5	#
Lines 16-24 Link Here
16	${CMAKE_CURRENT_BINARY_DIR}	13	${CMAKE_CURRENT_BINARY_DIR}
17	${CMAKE_CURRENT_SOURCE_DIR}	14	${CMAKE_CURRENT_SOURCE_DIR}
18	${CMAKE_CURRENT_SOURCE_DIR}/..	15	${CMAKE_CURRENT_SOURCE_DIR}/..
19	${CMAKE_CURRENT_SOURCE_DIR}/../../libtdevnc
20	${CMAKE_CURRENT_BINARY_DIR}/../../libtdevnc
21	${CMAKE_BINARY_DIR}
22	${TDE_INCLUDE_DIR}	16	${TDE_INCLUDE_DIR}
23	${TQT_INCLUDE_DIRS}	17	${TQT_INCLUDE_DIRS}
24	)	18	)
Lines 28-35 Link Here
28		22
29	tde_add_library( vnc STATIC_PIC AUTOMOC	23	tde_add_library( vnc STATIC_PIC AUTOMOC
30	SOURCES	24	SOURCES
31	kvncview.cpp scaling.cpp threads.cpp	25	kvncview.cpp threads.cpp colour.c d3des.c desktop.c rfbproto.c sockets.c
32	vncprefs.ui vnchostpref.cpp	26	vncauth.c vncprefs.ui vnchostpref.cpp
33	LINK
34	tdevncclient-static
35	)	27	)

Line 0 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/colour.c (+415 lines)
		1	/*
		2	* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
		3	*
		4	* This is free software; you can redistribute it and/or modify
		5	* it under the terms of the GNU General Public License as published by
		6	* the Free Software Foundation; either version 2 of the License, or
		7	* (at your option) any later version.
		8	*
		9	* This software is distributed in the hope that it will be useful,
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	* GNU General Public License for more details.
		13	*
		14	* You should have received a copy of the GNU General Public License
		15	* along with this software; if not, write to the Free Software
		16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
		17	* USA.
		18	*/
		19
		20	/*
		21	* colour.c - functions to deal with colour - i.e. RFB pixel formats, X visuals
		22	* and colormaps. Thanks to Grant McDorman for some of the ideas used here.
		23	*/
		24
		25	#include "vncviewer.h"
		26	#include <limits.h>
		27
		28
		29	#define INVALID_PIXEL 0xffffffff
		30	#define MAX_CMAP_SIZE 256
		31	#define BGR233_SIZE 256
		32	unsigned long BGR233ToPixel[BGR233_SIZE];
		33
		34	Colormap cmap;
		35	Visual *vis;
		36	unsigned int visdepth, visbpp;
		37	Bool allocColorFailed = False;
		38
		39	static int nBGR233ColoursAllocated;
		40
		41	static int GetBPPForDepth(int depth);
		42	static void SetupBGR233Map(void);
		43	static void AllocateExactBGR233Colours(void);
		44	static Bool AllocateBGR233Colour(int r, int g, int b);
		45
		46
		47	/*
		48	* SetVisualAndCmap() deals with the wonderful world of X "visuals" (which are
		49	* equivalent to the RFB protocol's "pixel format"). Having decided on the
		50	* best visual, it also creates a colormap if necessary, sets the appropriate
		51	* resources on the toplevel widget, and sets up the myFormat structure to
		52	* describe the pixel format in terms that the RFB server will be able to
		53	* understand.
		54	*
		55	* The algorithm for deciding which visual to use is as follows:
		56	*
		57	* If forceOwnCmap is true then we try to use a PseudoColor visual - we first
		58	* see if there's one of the same depth as the RFB server, followed by an 8-bit
		59	* deep one.
		60	*
		61	* If forceTrueColour is true then we try to use a TrueColor visual - if
		62	* requestedDepth is set then it must be of that depth, otherwise any depth
		63	* will be used.
		64	*
65	* Otherwise, we use the X server's default visual and colormap. If this is
66	* TrueColor then we just ask the RFB server for this format. If the default
67	* isn't TrueColor, or if useBGR233 is true, then we ask the RFB server for
68	* BGR233 pixel format and use a lookup table to translate to the nearest
69	* colours provided by the X server.
70	*/
71
72	void
73	SetVisualAndCmap()
74	{
75	/* just use default visual and colormap */
76
77	vis = DefaultVisual(dpy,DefaultScreen(dpy));
78	visdepth = DefaultDepth(dpy,DefaultScreen(dpy));
79	visbpp = GetBPPForDepth(visdepth);
80	cmap = DefaultColormap(dpy,DefaultScreen(dpy));
81
82	if (!appData.useBGR233 && (vis->class == TrueColor)) {
83
84	myFormat.bitsPerPixel = visbpp;
85	myFormat.depth = visdepth;
86	myFormat.trueColour = 1;
87	myFormat.bigEndian = (ImageByteOrder(dpy) == MSBFirst);
88	myFormat.redShift = ffs(vis->red_mask) - 1;
89	myFormat.greenShift = ffs(vis->green_mask) - 1;
90	myFormat.blueShift = ffs(vis->blue_mask) - 1;
91	myFormat.redMax = vis->red_mask >> myFormat.redShift;
92	myFormat.greenMax = vis->green_mask >> myFormat.greenShift;
93	myFormat.blueMax = vis->blue_mask >> myFormat.blueShift;
94
95	fprintf(stderr,
96	"Using default colormap which is TrueColor. Pixel format:\n");
97	PrintPixelFormat(&myFormat);
98	return;
99	}
100
101	appData.useBGR233 = True;
102
103	myFormat.bitsPerPixel = 8;
104	myFormat.depth = 8;
105	myFormat.trueColour = 1;
106	myFormat.bigEndian = 0;
107	myFormat.redMax = 7;
108	myFormat.greenMax = 7;
109	myFormat.blueMax = 3;
110	myFormat.redShift = 0;
111	myFormat.greenShift = 3;
112	myFormat.blueShift = 6;
113
114	fprintf(stderr,
115	"Using default colormap and translating from BGR233. Pixel format:\n");
116	PrintPixelFormat(&myFormat);
117
118	SetupBGR233Map();
119	}
120
121
122	/*
123	* GetBPPForDepth looks through the "pixmap formats" to find the bits-per-pixel
124	* for the given depth.
125	*/
126
127	static int
128	GetBPPForDepth(int depth)
129	{
130	XPixmapFormatValues *format;
131	int nformats;
132	int i;
133	int bpp;
134
135	format = XListPixmapFormats(dpy, &nformats);
136
137	for (i = 0; i < nformats; i++) {
138	if (format[i].depth == depth)
139	break;
140	}
141
142	if (i == nformats) {
143	fprintf(stderr,"no pixmap format for depth %d???\n", depth);
144	exit(1);
145	}
146
147	bpp = format[i].bits_per_pixel;
148
149	XFree(format);
150
151	if (bpp != 1 && bpp != 8 && bpp != 16 && bpp != 32) {
152	fprintf(stderr,"Can't cope with %d bits-per-pixel. Sorry.\n", bpp);
153	exit(1);
154	}
155
156	return bpp;
157	}
158
159
160
161	/*
162	* SetupBGR233Map() sets up the BGR233ToPixel array.
163	*
164	* It calls AllocateExactBGR233Colours to allocate some exact BGR233 colours
165	* (limited by space in the colormap and/or by the value of the nColours
166	* resource). If the number allocated is less than BGR233_SIZE then it fills
167	* the rest in using the "nearest" colours available. How this is done depends
168	* on the value of the useSharedColours resource. If it's false, we use only
169	* colours from the exact BGR233 colours we've just allocated. If it's true,
170	* then we also use other clients' "shared" colours available in the colormap.
171	*/
172
173	static void
174	SetupBGR233Map(void)
175	{
176	int r, g, b;
177	long i;
178	unsigned long nearestPixel = 0;
179	int cmapSize;
180	XColor cmapEntry[MAX_CMAP_SIZE];
181	Bool exactBGR233[MAX_CMAP_SIZE];
182	Bool shared[MAX_CMAP_SIZE];
183	Bool usedAsNearest[MAX_CMAP_SIZE];
184	int nSharedUsed = 0;
185
186	if (visdepth > 8) {
187	appData.nColours = 256; /* ignore nColours setting for > 8-bit deep */
188	}
189
190	for (i = 0; i < BGR233_SIZE; i++) {
191	BGR233ToPixel[i] = INVALID_PIXEL;
192	}
193
194	AllocateExactBGR233Colours();
195
196	fprintf(stderr,"Got %d exact BGR233 colours out of %d\n",
197	nBGR233ColoursAllocated, appData.nColours);
198
199	if (nBGR233ColoursAllocated < BGR233_SIZE) {
200
201	if (visdepth > 8) { /* shouldn't get here */
202	fprintf(stderr,"Error: couldn't allocate BGR233 colours even though "
203	"depth is %d\n", visdepth);
204	exit(1);
205	}
206
207	cmapSize = (1 << visdepth);
208
209	for (i = 0; i < cmapSize; i++) {
210	cmapEntry[i].pixel = i;
211	exactBGR233[i] = False;
212	shared[i] = False;
213	usedAsNearest[i] = False;
214	}
215
216	XQueryColors(dpy, cmap, cmapEntry, cmapSize);
217
218	/* mark all our exact BGR233 pixels */
219
220	for (i = 0; i < BGR233_SIZE; i++) {
221	if (BGR233ToPixel[i] != INVALID_PIXEL)
222	exactBGR233[BGR233ToPixel[i]] = True;
223	}
224
225	if (appData.useSharedColours) {
226
227	/* Try to find existing shared colours. This is harder than it sounds
228	because XQueryColors doesn't tell us whether colours are shared,
229	private or unallocated. What we do is go through the colormap and for
230	each pixel try to allocate exactly its RGB values. If this returns a
231	different pixel then it's definitely either a private or unallocated
232	pixel, so no use to us. If it returns us the same pixel again, then
233	it's likely that it's a shared colour - however, it is possible that
234	it was actually an unallocated pixel, which we've now allocated. We
235	minimise this possibility by going through the pixels in reverse order
236	- this helps becuse the X server allocates new pixels from the lowest
237	number up, so it should only be a problem for the lowest unallocated
238	pixel. Got that? */
239
240	for (i = cmapSize-1; i >= 0; i--) {
241	if (!exactBGR233[i] &&
242	XAllocColor(dpy, cmap, &cmapEntry[i])) {
243
244	if (cmapEntry[i].pixel == (unsigned long) i) {
245
246	shared[i] = True; /* probably shared */
247
248	} else {
249
250	/* "i" is either unallocated or private. We have now unnecessarily
251	allocated cmapEntry[i].pixel. Free it. */
252
253	XFreeColors(dpy, cmap, &cmapEntry[i].pixel, 1, 0);
254	}
255	}
256	}
257	}
258
259	/* Now fill in the nearest colours */
260
261	for (r = 0; r < 8; r++) {
262	for (g = 0; g < 8; g++) {
263	for (b = 0; b < 4; b++) {
264	if (BGR233ToPixel[(b<<6) \| (g<<3) \| r] == INVALID_PIXEL) {
265
266	unsigned long minDistance = ULONG_MAX;
267
268	for (i = 0; i < cmapSize; i++) {
269	if (exactBGR233[i] \|\| shared[i]) {
270	unsigned long distance
271	= (abs(cmapEntry[i].red - r * 65535 / 7)
272	+ abs(cmapEntry[i].green - g * 65535 / 7)
273	+ abs(cmapEntry[i].blue - b * 65535 / 3));
274
275	if (distance < minDistance) {
276	minDistance = distance;
277	nearestPixel = i;
278	}
279	}
280	}
281
282	BGR233ToPixel[(b<<6) \| (g<<3) \| r] = nearestPixel;
283	if (shared[nearestPixel] && !usedAsNearest[nearestPixel])
284	nSharedUsed++;
285	usedAsNearest[nearestPixel] = True;
286	}
287	}
288	}
289	}
290
291	/* Tidy up shared colours which we allocated but aren't going to use */
292
293	for (i = 0; i < cmapSize; i++) {
294	if (shared[i] && !usedAsNearest[i]) {
295	XFreeColors(dpy, cmap, (unsigned long *)&i, 1, 0);
296	}
297	}
298
299	fprintf(stderr,"Using %d existing shared colours\n", nSharedUsed);
300	}
301	}
302
303
304	/*
305	* AllocateExactBGR233Colours() attempts to allocate each of the colours in the
306	* BGR233 colour cube, stopping when an allocation fails. The order it does
307	* this in is such that we should get a fairly well spread subset of the cube,
308	* however many allocations are made. There's probably a neater algorithm for
309	* doing this, but it's not obvious to me anyway. The way this algorithm works
310	* is:
311	*
312	* At each stage, we introduce a new value for one of the primaries, and
313	* allocate all the colours with the new value of that primary and all previous
314	* values of the other two primaries. We start with r=0 as the "new" value
315	* for r, and g=0, b=0 as the "previous" values of g and b. So we get:
316	*
317	* New primary value Previous values of other primaries Colours allocated
318	* ----------------- ---------------------------------- -----------------
319	* r=0 g=0 b=0 r0 g0 b0
320	* g=7 r=0 b=0 r0 g7 b0
321	* b=3 r=0 g=0,7 r0 g0 b3
322	* r0 g7 b3
323	* r=7 g=0,7 b=0,3 r7 g0 b0
324	* r7 g0 b3
325	* r7 g7 b0
326	* r7 g7 b3
327	* g=3 r=0,7 b=0,3 r0 g3 b0
328	* r0 g3 b3
329	* r7 g3 b0
330	* r7 g3 b3
331	* ....etc.
332	* */
333
334	static void
335	AllocateExactBGR233Colours(void)
336	{
337	int rv[] = {0,7,3,5,1,6,2,4};
338	int gv[] = {0,7,3,5,1,6,2,4};
339	int bv[] = {0,3,1,2};
340	int rn = 0;
341	int gn = 1;
342	int bn = 1;
343	int ri, gi, bi;
344
345	nBGR233ColoursAllocated = 0;
346
347	while (1) {
348	if (rn == 8)
349	break;
350
351	ri = rn;
352	for (gi = 0; gi < gn; gi++) {
353	for (bi = 0; bi < bn; bi++) {
354	if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
355	return;
356	}
357	}
358	rn++;
359
360	if (gn == 8)
361	break;
362
363	gi = gn;
364	for (ri = 0; ri < rn; ri++) {
365	for (bi = 0; bi < bn; bi++) {
366	if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
367	return;
368	}
369	}
370	gn++;
371
372	if (bn < 4) {
373
374	bi = bn;
375	for (ri = 0; ri < rn; ri++) {
376	for (gi = 0; gi < gn; gi++) {
377	if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi]))
378	return;
379	}
380	}
381	bn++;
382	}
383	}
384	}
385
386
387	/*
388	* AllocateBGR233Colour() attempts to allocate the given BGR233 colour as a
389	* shared colormap entry, storing its pixel value in the BGR233ToPixel array.
390	* r is from 0 to 7, g from 0 to 7 and b from 0 to 3. It fails either when the
391	* allocation fails or when we would exceed the number of colours specified in
392	* the nColours resource.
393	*/
394
395	static Bool
396	AllocateBGR233Colour(int r, int g, int b)
397	{
398	XColor c;
399
400	if (nBGR233ColoursAllocated >= appData.nColours)
401	return False;
402
403	c.red = r * 65535 / 7;
404	c.green = g * 65535 / 7;
405	c.blue = b * 65535 / 3;
406
407	if (!XAllocColor(dpy, cmap, &c))
408	return False;
409
410	BGR233ToPixel[(b<<6) \| (g<<3) \| r] = c.pixel;
411
412	nBGR233ColoursAllocated++;
413
414	return True;
415	}

Line 0 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/d3des.c (+440 lines)
		1	/*
		2	* This is D3DES (V5.09) by Richard Outerbridge with the double and
		3	* triple-length support removed for use in VNC. Also the bytebit[] array
		4	* has been reversed so that the most significant bit in each byte of the
		5	* key is ignored, not the least significant.
		6	*
		7	* These changes are:
		8	* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
		9	*
		10	* This software is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
		13	*/
		14
		15	/* D3DES (V5.09) -
		16	*
		17	* A portable, public domain, version of the Data Encryption Standard.
		18	*
		19	* Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
		20	* Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
		21	* code; Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
		22	* Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
		23	* for humouring me on.
		24	*
		25	* Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
		26	* (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
		27	*/
		28
		29	#include "d3des.h"
		30
		31	static void scrunch(unsigned char , unsigned long );
		32	static void unscrun(unsigned long , unsigned char );
		33	static void desfunc(unsigned long , unsigned long );
		34	static void cookey(unsigned long *);
		35
		36	static unsigned long KnL[32] = { 0L };
		37	static unsigned long KnR[32] = { 0L };
		38	static unsigned long Kn3[32] = { 0L };
		39	static unsigned char Df_Key[24] = {
		40	0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
		41	0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
		42	0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67 };
		43
		44	static unsigned short bytebit[8] = {
		45	01, 02, 04, 010, 020, 040, 0100, 0200 };
		46
		47	static unsigned long bigbyte[24] = {
		48	0x800000L, 0x400000L, 0x200000L, 0x100000L,
		49	0x80000L, 0x40000L, 0x20000L, 0x10000L,
		50	0x8000L, 0x4000L, 0x2000L, 0x1000L,
		51	0x800L, 0x400L, 0x200L, 0x100L,
		52	0x80L, 0x40L, 0x20L, 0x10L,
		53	0x8L, 0x4L, 0x2L, 0x1L };
		54
		55	/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */
		56
		57	static unsigned char pc1[56] = {
		58	56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17,
		59	9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35,
		60	62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21,
		61	13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3 };
		62
		63	static unsigned char totrot[16] = {
		64	1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
65
66	static unsigned char pc2[48] = {
67	13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,
68	22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1,
69	40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
70	43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
71
72	void deskey(key, edf) /* Thanks to James Gillogly & Phil Karn! */
73	unsigned char *key;
74	int edf;
75	{
76	register int i, j, l, m, n;
77	unsigned char pc1m[56], pcr[56];
78	unsigned long kn[32];
79
80	for ( j = 0; j < 56; j++ ) {
81	l = pc1[j];
82	m = l & 07;
83	pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
84	}
85	for( i = 0; i < 16; i++ ) {
86	if( edf == DE1 ) m = (15 - i) << 1;
87	else m = i << 1;
88	n = m + 1;
89	kn[m] = kn[n] = 0L;
90	for( j = 0; j < 28; j++ ) {
91	l = j + totrot[i];
92	if( l < 28 ) pcr[j] = pc1m[l];
93	else pcr[j] = pc1m[l - 28];
94	}
95	for( j = 28; j < 56; j++ ) {
96	l = j + totrot[i];
97	if( l < 56 ) pcr[j] = pc1m[l];
98	else pcr[j] = pc1m[l - 28];
99	}
100	for( j = 0; j < 24; j++ ) {
101	if( pcr[pc2[j]] ) kn[m] \|= bigbyte[j];
102	if( pcr[pc2[j+24]] ) kn[n] \|= bigbyte[j];
103	}
104	}
105	cookey(kn);
106	return;
107	}
108
109	static void cookey(raw1)
110	register unsigned long *raw1;
111	{
112	register unsigned long cook, raw0;
113	unsigned long dough[32];
114	register int i;
115
116	cook = dough;
117	for( i = 0; i < 16; i++, raw1++ ) {
118	raw0 = raw1++;
119	cook = (raw0 & 0x00fc0000L) << 6;
120	cook \|= (raw0 & 0x00000fc0L) << 10;
121	cook \|= (raw1 & 0x00fc0000L) >> 10;
122	cook++ \|= (raw1 & 0x00000fc0L) >> 6;
123	cook = (raw0 & 0x0003f000L) << 12;
124	cook \|= (raw0 & 0x0000003fL) << 16;
125	cook \|= (raw1 & 0x0003f000L) >> 4;
126	cook++ \|= (raw1 & 0x0000003fL);
127	}
128	usekey(dough);
129	return;
130	}
131
132	void cpkey(into)
133	register unsigned long *into;
134	{
135	register unsigned long from, endp;
136
137	from = KnL, endp = &KnL[32];
138	while( from < endp ) into++ = from++;
139	return;
140	}
141
142	void usekey(from)
143	register unsigned long *from;
144	{
145	register unsigned long to, endp;
146
147	to = KnL, endp = &KnL[32];
148	while( to < endp ) to++ = from++;
149	return;
150	}
151
152	void des(inblock, outblock)
153	unsigned char inblock, outblock;
154	{
155	unsigned long work[2];
156
157	scrunch(inblock, work);
158	desfunc(work, KnL);
159	unscrun(work, outblock);
160	return;
161	}
162
163	static void scrunch(outof, into)
164	register unsigned char *outof;
165	register unsigned long *into;
166	{
167	into = (outof++ & 0xffL) << 24;
168	into \|= (outof++ & 0xffL) << 16;
169	into \|= (outof++ & 0xffL) << 8;
170	into++ \|= (outof++ & 0xffL);
171	into = (outof++ & 0xffL) << 24;
172	into \|= (outof++ & 0xffL) << 16;
173	into \|= (outof++ & 0xffL) << 8;
174	into \|= (outof & 0xffL);
175	return;
176	}
177
178	static void unscrun(outof, into)
179	register unsigned long *outof;
180	register unsigned char *into;
181	{
182	into++ = (outof >> 24) & 0xffL;
183	into++ = (outof >> 16) & 0xffL;
184	into++ = (outof >> 8) & 0xffL;
185	into++ = outof++ & 0xffL;
186	into++ = (outof >> 24) & 0xffL;
187	into++ = (outof >> 16) & 0xffL;
188	into++ = (outof >> 8) & 0xffL;
189	into = outof & 0xffL;
190	return;
191	}
192
193	static unsigned long SP1[64] = {
194	0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
195	0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
196	0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
197	0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
198	0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
199	0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
200	0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
201	0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
202	0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
203	0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
204	0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
205	0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
206	0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
207	0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
208	0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
209	0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };
210
211	static unsigned long SP2[64] = {
212	0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
213	0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
214	0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
215	0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
216	0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
217	0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
218	0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
219	0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
220	0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
221	0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
222	0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
223	0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
224	0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
225	0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
226	0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
227	0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };
228
229	static unsigned long SP3[64] = {
230	0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
231	0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
232	0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
233	0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
234	0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
235	0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
236	0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
237	0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
238	0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
239	0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
240	0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
241	0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
242	0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
243	0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
244	0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
245	0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };
246
247	static unsigned long SP4[64] = {
248	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
249	0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
250	0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
251	0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
252	0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
253	0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
254	0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
255	0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
256	0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
257	0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
258	0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
259	0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
260	0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
261	0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
262	0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
263	0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };
264
265	static unsigned long SP5[64] = {
266	0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
267	0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
268	0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
269	0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
270	0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
271	0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
272	0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
273	0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
274	0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
275	0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
276	0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
277	0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
278	0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
279	0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
280	0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
281	0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };
282
283	static unsigned long SP6[64] = {
284	0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
285	0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
286	0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
287	0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
288	0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
289	0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
290	0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
291	0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
292	0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
293	0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
294	0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
295	0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
296	0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
297	0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
298	0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
299	0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };
300
301	static unsigned long SP7[64] = {
302	0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
303	0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
304	0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
305	0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
306	0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
307	0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
308	0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
309	0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
310	0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
311	0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
312	0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
313	0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
314	0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
315	0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
316	0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
317	0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
318
319	static unsigned long SP8[64] = {
320	0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
321	0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
322	0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
323	0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
324	0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
325	0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
326	0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
327	0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
328	0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
329	0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
330	0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
331	0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
332	0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
333	0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
334	0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
335	0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
336
337	static void desfunc(block, keys)
338	register unsigned long block, keys;
339	{
340	register unsigned long fval, work, right, leftt;
341	register int round;
342
343	leftt = block[0];
344	right = block[1];
345	work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
346	right ^= work;
347	leftt ^= (work << 4);
348	work = ((leftt >> 16) ^ right) & 0x0000ffffL;
349	right ^= work;
350	leftt ^= (work << 16);
351	work = ((right >> 2) ^ leftt) & 0x33333333L;
352	leftt ^= work;
353	right ^= (work << 2);
354	work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
355	leftt ^= work;
356	right ^= (work << 8);
357	right = ((right << 1) \| ((right >> 31) & 1L)) & 0xffffffffL;
358	work = (leftt ^ right) & 0xaaaaaaaaL;
359	leftt ^= work;
360	right ^= work;
361	leftt = ((leftt << 1) \| ((leftt >> 31) & 1L)) & 0xffffffffL;
362
363	for( round = 0; round < 8; round++ ) {
364	work = (right << 28) \| (right >> 4);
365	work ^= *keys++;
366	fval = SP7[ work & 0x3fL];
367	fval \|= SP5[(work >> 8) & 0x3fL];
368	fval \|= SP3[(work >> 16) & 0x3fL];
369	fval \|= SP1[(work >> 24) & 0x3fL];
370	work = right ^ *keys++;
371	fval \|= SP8[ work & 0x3fL];
372	fval \|= SP6[(work >> 8) & 0x3fL];
373	fval \|= SP4[(work >> 16) & 0x3fL];
374	fval \|= SP2[(work >> 24) & 0x3fL];
375	leftt ^= fval;
376	work = (leftt << 28) \| (leftt >> 4);
377	work ^= *keys++;
378	fval = SP7[ work & 0x3fL];
379	fval \|= SP5[(work >> 8) & 0x3fL];
380	fval \|= SP3[(work >> 16) & 0x3fL];
381	fval \|= SP1[(work >> 24) & 0x3fL];
382	work = leftt ^ *keys++;
383	fval \|= SP8[ work & 0x3fL];
384	fval \|= SP6[(work >> 8) & 0x3fL];
385	fval \|= SP4[(work >> 16) & 0x3fL];
386	fval \|= SP2[(work >> 24) & 0x3fL];
387	right ^= fval;
388	}
389
390	right = (right << 31) \| (right >> 1);
391	work = (leftt ^ right) & 0xaaaaaaaaL;
392	leftt ^= work;
393	right ^= work;
394	leftt = (leftt << 31) \| (leftt >> 1);
395	work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
396	right ^= work;
397	leftt ^= (work << 8);
398	work = ((leftt >> 2) ^ right) & 0x33333333L;
399	right ^= work;
400	leftt ^= (work << 2);
401	work = ((right >> 16) ^ leftt) & 0x0000ffffL;
402	leftt ^= work;
403	right ^= (work << 16);
404	work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
405	leftt ^= work;
406	right ^= (work << 4);
407	*block++ = right;
408	*block = leftt;
409	return;
410	}
411
412	/* Validation sets:
413	*
414	* Single-length key, single-length plaintext -
415	* Key : 0123 4567 89ab cdef
416	* Plain : 0123 4567 89ab cde7
417	* Cipher : c957 4425 6a5e d31d
418	*
419	* Double-length key, single-length plaintext -
420	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210
421	* Plain : 0123 4567 89ab cde7
422	* Cipher : 7f1d 0a77 826b 8aff
423	*
424	* Double-length key, double-length plaintext -
425	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210
426	* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff
427	* Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
428	*
429	* Triple-length key, single-length plaintext -
430	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
431	* Plain : 0123 4567 89ab cde7
432	* Cipher : de0b 7c06 ae5e 0ed5
433	*
434	* Triple-length key, double-length plaintext -
435	* Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
436	* Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff
437	* Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
438	*
439	* d3des V5.0a rwo 9208.07 18:44 Graven Imagery
440	**********************************************************************/

Lines 2-9 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.cpp (-74 / +70 lines)
2	kvncview.cpp - main widget	2	kvncview.cpp - main widget
3	-------------------	3	-------------------
4	begin : Thu Dec 20 15:11:42 CET 2001	4	begin : Thu Dec 20 15:11:42 CET 2001
5	copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>	5	copyright : (C) 2001-2003 by Tim Jansen
6	(C) 2001-2003 by Tim Jansen
7	email : tim@tjansen.de	6	email : tim@tjansen.de
8	***************************************************************************/	7	***************************************************************************/
9		8
Lines 35-42 Link Here
35	#include <tqbitmap.h>	34	#include <tqbitmap.h>
36	#include <tqmutex.h>	35	#include <tqmutex.h>
37	#include <tqvbox.h>	36	#include <tqvbox.h>
38	#include <tqtimer.h>
39	#include <tqpainter.h>
40	#include <tqwaitcondition.h>	37	#include <tqwaitcondition.h>
41		38
42	#include "vncviewer.h"	39	#include "vncviewer.h"
Lines 50-55 Link Here
50	* application resource specs. The AppData structure is defined in the header	47	* application resource specs. The AppData structure is defined in the header
51	* file.	48	* file.
52	*/	49	*/
		50	AppData appData;
53	bool appDataConfigured = false;	51	bool appDataConfigured = false;
54		52
55	Display* dpy;	53	Display* dpy;
Lines 75-81 Link Here
75	DotCursorState dotCursorState,	73	DotCursorState dotCursorState,
76	const TQString &encodings) :	74	const TQString &encodings) :
77	KRemoteView(parent, name, TQt::WResizeNoErase \| TQt::WRepaintNoErase \| TQt::WStaticContents),	75	KRemoteView(parent, name, TQt::WResizeNoErase \| TQt::WRepaintNoErase \| TQt::WStaticContents),
78	m_cthreadObject(this, m_quitFlag),	76	m_cthread(this, m_wthread, m_quitFlag),
		77	m_wthread(this, m_quitFlag),
79	m_quitFlag(false),	78	m_quitFlag(false),
80	m_enableFramebufferLocking(false),	79	m_enableFramebufferLocking(false),
81	m_scaling(false),	80	m_scaling(false),
Lines 148-153 Link Here
148		147
149	void KVncView::startQuitting() {	148	void KVncView::startQuitting() {
150	m_quitFlag = true;	149	m_quitFlag = true;
		150	m_wthread.kick();
		151	m_cthread.kick();
151	}	152	}
152		153
153	bool KVncView::isQuitting() {	154	bool KVncView::isQuitting() {
Lines 156-192 Link Here
156		157
157	void KVncView::configureApp(Quality q, const TQString specialEncodings) {	158	void KVncView::configureApp(Quality q, const TQString specialEncodings) {
158	appDataConfigured = true;	159	appDataConfigured = true;
159	m_cthreadObject.cl->appData.shareDesktop = 1;	160	appData.shareDesktop = 1;
160	m_cthreadObject.cl->appData.viewOnly = 0;	161	appData.viewOnly = 0;
161		162
162	if (q == QUALITY_LOW) {	163	if (q == QUALITY_LOW) {
163	m_cthreadObject.cl->appData.useBGR233 = 1;	164	appData.useBGR233 = 1;
164	m_cthreadObject.cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";	165	appData.encodingsString = "background copyrect softcursor tight zlib hextile raw";
165	m_cthreadObject.cl->appData.compressLevel = 9;	166	appData.compressLevel = -1;
166	m_cthreadObject.cl->appData.qualityLevel = 1;	167	appData.qualityLevel = 1;
167	m_cthreadObject.cl->appData.useRemoteCursor = 1;	168	appData.dotCursor = 1;
168	}	169	}
169	else if (q == QUALITY_MEDIUM) {	170	else if (q == QUALITY_MEDIUM) {
170	m_cthreadObject.cl->appData.useBGR233 = 0;	171	appData.useBGR233 = 0;
171	m_cthreadObject.cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";	172	appData.encodingsString = "background copyrect softcursor tight zlib hextile raw";
172	m_cthreadObject.cl->appData.compressLevel = 5;	173	appData.compressLevel = -1;
173	m_cthreadObject.cl->appData.qualityLevel = 7;	174	appData.qualityLevel = 7;
174	m_cthreadObject.cl->appData.useRemoteCursor = 1;	175	appData.dotCursor = 1;
175	}	176	}
176	else if ((q == QUALITY_HIGH) \|\| (q == QUALITY_UNKNOWN)) {	177	else if ((q == QUALITY_HIGH) \|\| (q == QUALITY_UNKNOWN)) {
177	m_cthreadObject.cl->appData.useBGR233 = 0;	178	appData.useBGR233 = 0;
178	m_cthreadObject.cl->appData.encodingsString = "copyrect hextile raw";	179	appData.encodingsString = "copyrect softcursor hextile raw";
179	m_cthreadObject.cl->appData.compressLevel = 0;	180	appData.compressLevel = -1;
180	m_cthreadObject.cl->appData.qualityLevel = 9;	181	appData.qualityLevel = 9;
181	m_cthreadObject.cl->appData.useRemoteCursor = 1;	182	appData.dotCursor = 1;
182	}	183	}
183		184
184	if (!specialEncodings.isNull()) {	185	if (!specialEncodings.isNull())
185	m_cthreadObject.cl->appData.encodingsString = specialEncodings.latin1();	186	appData.encodingsString = specialEncodings.latin1();
186	}	187
		188	appData.nColours = 256;
		189	appData.useSharedColours = 1;
		190	appData.requestedDepth = 0;
		191
		192	appData.rawDelay = 0;
		193	appData.copyRectDelay = 0;
187		194
188	m_cthreadObject.cl->appData.nColours = 256;	195	if (!appData.dotCursor)
189	m_cthreadObject.cl->appData.requestedDepth = 0;	196	m_cursorState = DOT_CURSOR_OFF;
		197	showDotCursorInternal();
190	}	198	}
191		199
192	bool KVncView::checkLocalKRfb() {	200	bool KVncView::checkLocalKRfb() {
Lines 289-298 Link Here
289		297
290	setStatus(REMOTE_VIEW_CONNECTING);	298	setStatus(REMOTE_VIEW_CONNECTING);
291		299
292	m_cthreadObject.moveToThread(&m_cthread);
293	TQTimer::singleShot(0, &m_cthreadObject, SLOT(run()));
294	m_cthread.start();	300	m_cthread.start();
295
296	setBackgroundMode(TQt::NoBackground);	301	setBackgroundMode(TQt::NoBackground);
297	return true;	302	return true;
298	}	303	}
Lines 301-306 Link Here
301	{	306	{
302	startQuitting();	307	startQuitting();
303	m_cthread.wait();	308	m_cthread.wait();
		309	m_wthread.wait();
		310	freeResources();
304	}	311	}
305		312
306	bool KVncView::supportsLocalCursor() const {	313	bool KVncView::supportsLocalCursor() const {
Lines 345-360 Link Here
345	setMaximumSize(m_framebufferSize);	352	setMaximumSize(m_framebufferSize);
346	setMinimumSize(m_framebufferSize.width()/16,	353	setMinimumSize(m_framebufferSize.width()/16,
347	m_framebufferSize.height()/16);	354	m_framebufferSize.height()/16);
348
349	m_cthreadObject.setScaling(width(), height());
350	}	355	}
351	else {	356	else
352	setFixedSize(m_framebufferSize);	357	setFixedSize(m_framebufferSize);
353	m_cthreadObject.setScaling(-1, -1);
354	}
355
356	// Force full redraw
357	drawRegion(0, 0, width(), height());
358	}	358	}
359	}	359	}
360		360
Lines 365-382 Link Here
365	e->rect().height());	365	e->rect().height());
366	}	366	}
367		367
368	void KVncView::resizeEvent(TQResizeEvent *e) {
369	if (m_scaling) {
370	m_cthreadObject.setScaling(width(), height());
371
372	// Force full redraw
373	drawRegion(0, 0, width(), height());
374	}
375	}
376
377	void KVncView::drawRegion(int x, int y, int w, int h) {	368	void KVncView::drawRegion(int x, int y, int w, int h) {
378	TQPainter painter(this);	369	if (m_scaling)
379	painter.drawImage(TQRect(x, y, w, h), m_cthreadObject.image(x, y, w, h));	370	DrawZoomedScreenRegionX11Thread(winId(), width(), height(),
		371	x, y, w, h);
		372	else
		373	DrawScreenRegionX11Thread(winId(), x, y, w, h);
380	}	374	}
381		375
382	void KVncView::customEvent(TQCustomEvent *e)	376	void KVncView::customEvent(TQCustomEvent *e)
Lines 391-396 Link Here
391	setFixedSize(m_framebufferSize);	385	setFixedSize(m_framebufferSize);
392	emit changeSize(sre->width(), sre->height());	386	emit changeSize(sre->width(), sre->height());
393	}	387	}
		388	else if (e->type() == DesktopInitEventType) {
		389	m_cthread.desktopInit();
		390	}
394	else if (e->type() == StatusChangeEventType) {	391	else if (e->type() == StatusChangeEventType) {
395	StatusChangeEvent sce = (StatusChangeEvent) e;	392	StatusChangeEvent sce = (StatusChangeEvent) e;
396	setStatus(sce->status());	393	setStatus(sce->status());
Lines 448-454 Link Here
448	wallet->setFolder(krdc_folder);	445	wallet->setFolder(krdc_folder);
449	TQString newPass;	446	TQString newPass;
450	if ( wallet->hasEntry(kvncview->host()) && !wallet->readPassword(kvncview->host(), newPass) ) {	447	if ( wallet->hasEntry(kvncview->host()) && !wallet->readPassword(kvncview->host(), newPass) ) {
451	password=newPass;	448	password=newPass.latin1();
452	}	449	}
453	}	450	}
454	}	451	}
Lines 566-578 Link Here
566	x = (x * m_framebufferSize.width()) / width();	563	x = (x * m_framebufferSize.width()) / width();
567	y = (y * m_framebufferSize.height()) / height();	564	y = (y * m_framebufferSize.height()) / height();
568	}	565	}
569	m_cthreadObject.queueMouseEvent(x, y, m_buttonMask);	566	m_wthread.queueMouseEvent(x, y, m_buttonMask);
570		567
571	if (m_enableClientCursor) {	568	if (m_enableClientCursor)
572	// FIXME	569	DrawCursorX11Thread(x, y); // in rfbproto.c
573	// How to draw soft cursor?
574	// DrawCursorX11Thread(x, y); // in rfbproto.c
575	}
576	}	570	}
577		571
578	void KVncView::mousePressEvent(TQMouseEvent *e) {	572	void KVncView::mousePressEvent(TQMouseEvent *e) {
Lines 613-620 Link Here
613	x = (x * m_framebufferSize.width()) / width();	607	x = (x * m_framebufferSize.width()) / width();
614	y = (y * m_framebufferSize.height()) / height();	608	y = (y * m_framebufferSize.height()) / height();
615	}	609	}
616	m_cthreadObject.queueMouseEvent(x, y, eb\|m_buttonMask);	610	m_wthread.queueMouseEvent(x, y, eb\|m_buttonMask);
617	m_cthreadObject.queueMouseEvent(x, y, m_buttonMask);	611	m_wthread.queueMouseEvent(x, y, m_buttonMask);
618	e->accept();	612	e->accept();
619	}	613	}
620		614
Lines 627-651 Link Here
627	KKeyNative k(xe);	621	KKeyNative k(xe);
628	uint mod = k.mod();	622	uint mod = k.mod();
629	if (mod & KKeyNative::modX(KKey::SHIFT))	623	if (mod & KKeyNative::modX(KKey::SHIFT))
630	m_cthreadObject.queueKeyEvent(XK_Shift_L, true);	624	m_wthread.queueKeyEvent(XK_Shift_L, true);
631	if (mod & KKeyNative::modX(KKey::CTRL))	625	if (mod & KKeyNative::modX(KKey::CTRL))
632	m_cthreadObject.queueKeyEvent(XK_Control_L, true);	626	m_wthread.queueKeyEvent(XK_Control_L, true);
633	if (mod & KKeyNative::modX(KKey::ALT))	627	if (mod & KKeyNative::modX(KKey::ALT))
634	m_cthreadObject.queueKeyEvent(XK_Alt_L, true);	628	m_wthread.queueKeyEvent(XK_Alt_L, true);
635	if (mod & KKeyNative::modX(KKey::WIN))	629	if (mod & KKeyNative::modX(KKey::WIN))
636	m_cthreadObject.queueKeyEvent(XK_Meta_L, true);	630	m_wthread.queueKeyEvent(XK_Meta_L, true);
637		631
638	m_cthreadObject.queueKeyEvent(k.sym(), true);	632	m_wthread.queueKeyEvent(k.sym(), true);
639	m_cthreadObject.queueKeyEvent(k.sym(), false);	633	m_wthread.queueKeyEvent(k.sym(), false);
640		634
641	if (mod & KKeyNative::modX(KKey::WIN))	635	if (mod & KKeyNative::modX(KKey::WIN))
642	m_cthreadObject.queueKeyEvent(XK_Meta_L, false);	636	m_wthread.queueKeyEvent(XK_Meta_L, false);
643	if (mod & KKeyNative::modX(KKey::ALT))	637	if (mod & KKeyNative::modX(KKey::ALT))
644	m_cthreadObject.queueKeyEvent(XK_Alt_L, false);	638	m_wthread.queueKeyEvent(XK_Alt_L, false);
645	if (mod & KKeyNative::modX(KKey::CTRL))	639	if (mod & KKeyNative::modX(KKey::CTRL))
646	m_cthreadObject.queueKeyEvent(XK_Control_L, false);	640	m_wthread.queueKeyEvent(XK_Control_L, false);
647	if (mod & KKeyNative::modX(KKey::SHIFT))	641	if (mod & KKeyNative::modX(KKey::SHIFT))
648	m_cthreadObject.queueKeyEvent(XK_Shift_L, false);	642	m_wthread.queueKeyEvent(XK_Shift_L, false);
649		643
650	m_mods.clear();	644	m_mods.clear();
651	}	645	}
Lines 678-684 Link Here
678	else	672	else
679	unpressModifiers();	673	unpressModifiers();
680	}	674	}
681	m_cthreadObject.queueKeyEvent(s, pressed);	675	m_wthread.queueKeyEvent(s, pressed);
682	}	676	}
683	return true;	677	return true;
684	}	678	}
Lines 687-693 Link Here
687	TQValueList<unsigned int> keys = m_mods.keys();	681	TQValueList<unsigned int> keys = m_mods.keys();
688	TQValueList<unsigned int>::const_iterator it = keys.begin();	682	TQValueList<unsigned int>::const_iterator it = keys.begin();
689	while (it != keys.end()) {	683	while (it != keys.end()) {
690	m_cthreadObject.queueKeyEvent(*it, false);	684	m_wthread.queueKeyEvent(*it, false);
691	it++;	685	it++;
692	}	686	}
693	m_mods.clear();	687	m_mods.clear();
Lines 725-731 Link Here
725	if (text.length() > MAX_SELECTION_LENGTH)	719	if (text.length() > MAX_SELECTION_LENGTH)
726	return;	720	return;
727		721
728	m_cthreadObject.queueClientCut(text);	722	m_wthread.queueClientCut(text);
729	}	723	}
730		724
731	void KVncView::selectionChanged() {	725	void KVncView::selectionChanged() {
Lines 744-750 Link Here
744	if (text.length() > MAX_SELECTION_LENGTH)	738	if (text.length() > MAX_SELECTION_LENGTH)
745	return;	739	return;
746		740
747	m_cthreadObject.queueClientCut(text);	741	m_wthread.queueClientCut(text);
748	}	742	}
749		743
750		744
Lines 776-782 Link Here
776	locks and signals are there to protect against deadlocks and other	770	locks and signals are there to protect against deadlocks and other
777	horribleness. Be careful making changes here.	771	horribleness. Be careful making changes here.
778	*/	772	*/
779	int getPassword(char * &passwd) {	773	int getPassword(char *passwd, int pwlen) {
780	int retV = 0;	774	int retV = 0;
781		775
782	//Prepare the system	776	//Prepare the system
Lines 803-809 Link Here
803		797
804	//Process the password if we got it, clear it if we didn't	798	//Process the password if we got it, clear it if we didn't
805	if (retV) {	799	if (retV) {
806	passwd = strdup(password.utf8());	800	strncpy(passwd, password.utf8(), pwlen);
		801	} else {
		802	passwd[0] = 0;
807	}	803	}
808		804
809	//Pack up and go home	805	//Pack up and go home

Lines 2-9 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.h (-7 / +4 lines)
2	kvncview.h - widget that shows the vnc client	2	kvncview.h - widget that shows the vnc client
3	-------------------	3	-------------------
4	begin : Thu Dec 20 15:11:42 CET 2001	4	begin : Thu Dec 20 15:11:42 CET 2001
5	copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>	5	copyright : (C) 2001-2003 by Tim Jansen
6	(C) 2001-2003 by Tim Jansen
7	email : tim@tjansen.de	6	email : tim@tjansen.de
8	***************************************************************************/	7	***************************************************************************/
9		8
Lines 25-30 Link Here
25		24
26	#include "pointerlatencyometer.h"	25	#include "pointerlatencyometer.h"
27	#include "hostpreferences.h"	26	#include "hostpreferences.h"
		27	#include "vnctypes.h"
28	#include "threads.h"	28	#include "threads.h"
29		29
30	class TQClipBoard;	30	class TQClipBoard;
Lines 34-41 Link Here
34	TQ_OBJECT	34	TQ_OBJECT
35		35
36	private:	36	private:
37	ControllerThreadObject m_cthreadObject;	37	ControllerThread m_cthread;
38	TQEventLoopThread m_cthread;	38	WriterThread m_wthread;
39	volatile bool m_quitFlag; // if set: all threads should die ASAP	39	volatile bool m_quitFlag; // if set: all threads should die ASAP
40	TQMutex m_framebufferLock;	40	TQMutex m_framebufferLock;
41	bool m_enableFramebufferLocking;	41	bool m_enableFramebufferLocking;
Lines 74-80 Link Here
74	void mouseMoveEvent(TQMouseEvent*);	74	void mouseMoveEvent(TQMouseEvent*);
75	void wheelEvent(TQWheelEvent *);	75	void wheelEvent(TQWheelEvent *);
76	void focusOutEvent(TQFocusEvent *);	76	void focusOutEvent(TQFocusEvent *);
77	void resizeEvent(TQResizeEvent *);
78	bool x11Event(XEvent*);	77	bool x11Event(XEvent*);
79		78
80	public:	79	public:
Lines 117-124 Link Here
117		116
118		117
119	private slots:	118	private slots:
120	// void requestPassword();
121
122	void clipboardChanged();	119	void clipboardChanged();
123	void selectionChanged();	120	void selectionChanged();
124	};	121	};

Lines 1-331 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/scaling.cpp (-331 lines)
1	/****************************************************************************
2	**
3	** Copyright (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>
4	**
5	** This file is part of TDE.
6	**
7	** This program is free software; you can redistribute it and/or modify
8	** it under the terms of the GNU General Public License as published by
9	** the Free Software Foundation; either version 2 of the License, or
10	** (at your option) any later version.
11	**
12	** This program is distributed in the hope that it will be useful,
13	** but WITHOUT ANY WARRANTY; without even the implied warranty of
14	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	** GNU General Public License for more details.
16	**
17	** You should have received a copy of the GNU General Public License
18	** along with this program; see the file COPYING. If not, write to
19	** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20	** Boston, MA 02110-1301, USA.
21	**
22	****************************************************************************/
23
24	#include <tqimage.h>
25
26	/*!
27
28	Smooth scaling function with ability to limit scaled region
29	The selection rectangle is given in terms of destination coordinates
30	It leaves areas outside of the selection rectangle undefined...
31
32	Function code originally taken from qimage.cpp pnmscale () and modified
33	to only scale a section of the source
34
35	This function uses code based on pnmscale.c by Jef Poskanzer.
36
37	pnmscale.c - read a portable anymap and scale it
38
39	\legalese
40
41	Copyright (C) 1989, 1991 by Jef Poskanzer.
42
43	Permission to use, copy, modify, and distribute this software and
44	its documentation for any purpose and without fee is hereby
45	granted, provided that the above copyright notice appear in all
46	copies and that both that copyright notice and this permission
47	notice appear in supporting documentation. This software is
48	provided "as is" without express or implied warranty.
49
50	*/
51
52	void pnmscale_fractional(const TQImage& src, TQImage& dst, int x, int y, int w, int h)
53	{
54	TQRgb* xelrow = 0;
55	TQRgb* tempxelrow = 0;
56	TQRgb* xP;
57	TQRgb* nxP;
58	int rows, cols, rowsread, newrows, newcols;
59	int row, col, needtoreadrow;
60	const uchar maxval = 255;
61	double xscale, yscale;
62	long sxscale, syscale;
63	long fracrowtofill, fracrowleft;
64	long* as;
65	long* rs;
66	long* gs;
67	long* bs;
68	int rowswritten = 0;
69	int colswritten = 0;
70
71	cols = src.width();
72	rows = src.height();
73	newcols = dst.width();
74	newrows = dst.height();
75
76	long SCALE;
77	long HALFSCALE;
78
79	if (cols > 4096)
80	{
81	SCALE = 4096;
82	HALFSCALE = 2048;
83	}
84	else
85	{
86	int fac = 4096;
87
88	while (cols * fac > 4096)
89	{
90	fac /= 2;
91	}
92
93	SCALE = fac * cols;
94	HALFSCALE = fac * cols / 2;
95	}
96
97	xscale = (double) newcols / (double) cols;
98	yscale = (double) newrows / (double) rows;
99
100	sxscale = (long)(xscale * SCALE);
101	syscale = (long)(yscale * SCALE);
102
103	if ( newrows != rows ) /* shortcut Y scaling if possible */
104	tempxelrow = new TQRgb[cols];
105
106	if ( src.hasAlphaBuffer() ) {
107	dst.setAlphaBuffer(TRUE);
108	as = new long[cols];
109	for ( col = 0; col < cols; ++col )
110	as[col] = HALFSCALE;
111	} else {
112	as = 0;
113	}
114	rs = new long[cols];
115	gs = new long[cols];
116	bs = new long[cols];
117	rowsread = 0;
118	fracrowleft = syscale;
119	needtoreadrow = 1;
120	for ( col = 0; col < cols; ++col )
121	rs[col] = gs[col] = bs[col] = HALFSCALE;
122	fracrowtofill = SCALE;
123
124	for ( row = 0; row < newrows; ++row ) {
125	/* First scale Y from xelrow into tempxelrow. */
126	if ( newrows == rows ) {
127	/* shortcut Y scaling if possible */
128	tempxelrow = xelrow = (TQRgb*)src.scanLine(rowsread++);
129	} else {
130	while ( fracrowleft < fracrowtofill ) {
131	if ( needtoreadrow && rowsread < rows )
132	xelrow = (TQRgb*)src.scanLine(rowsread++);
133	for ( col = 0, xP = xelrow; col < cols; ++col, ++xP ) {
134	if ((rowswritten >= y) && (rowswritten <= (y + h))) {
135	if (as) {
136	as[col] += fracrowleft * tqAlpha( *xP );
137	rs[col] += fracrowleft * tqRed( xP ) tqAlpha( *xP ) / 255;
138	gs[col] += fracrowleft * tqGreen( xP ) tqAlpha( *xP ) / 255;
139	bs[col] += fracrowleft * tqBlue( xP ) tqAlpha( *xP ) / 255;
140	} else {
141	rs[col] += fracrowleft * tqRed( *xP );
142	gs[col] += fracrowleft * tqGreen( *xP );
143	bs[col] += fracrowleft * tqBlue( *xP );
144	}
145	}
146	}
147	fracrowtofill -= fracrowleft;
148	fracrowleft = syscale;
149	needtoreadrow = 1;
150	}
151	/* Now fracrowleft is >= fracrowtofill, so we can produce a row. */
152	if ( needtoreadrow && rowsread < rows ) {
153	xelrow = (TQRgb*)src.scanLine(rowsread++);
154	needtoreadrow = 0;
155	}
156	long a=0;
157	for ( col = 0, xP = xelrow, nxP = tempxelrow, colswritten = 0;
158	col < cols; ++col, ++xP, ++nxP, ++colswritten )
159	{
160	if ((rowswritten >= y) && (rowswritten <= (y + h))) {
161	long r, g, b;
162
163	if ( as ) {
164	r = rs[col] + fracrowtofill * tqRed( xP ) tqAlpha( *xP ) / 255;
165	g = gs[col] + fracrowtofill * tqGreen( xP ) tqAlpha( *xP ) / 255;
166	b = bs[col] + fracrowtofill * tqBlue( xP ) tqAlpha( *xP ) / 255;
167	a = as[col] + fracrowtofill * tqAlpha( *xP );
168	if ( a ) {
169	r = r * 255 / a * SCALE;
170	g = g * 255 / a * SCALE;
171	b = b * 255 / a * SCALE;
172	}
173	} else {
174	r = rs[col] + fracrowtofill * tqRed( *xP );
175	g = gs[col] + fracrowtofill * tqGreen( *xP );
176	b = bs[col] + fracrowtofill * tqBlue( *xP );
177	}
178	r /= SCALE;
179	if ( r > maxval ) r = maxval;
180	g /= SCALE;
181	if ( g > maxval ) g = maxval;
182	b /= SCALE;
183	if ( b > maxval ) b = maxval;
184	if ( as ) {
185	a /= SCALE;
186	if ( a > maxval ) a = maxval;
187	*nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
188	as[col] = HALFSCALE;
189	} else {
190	*nxP = tqRgb( (int)r, (int)g, (int)b );
191	}
192	rs[col] = gs[col] = bs[col] = HALFSCALE;
193	}
194	}
195	fracrowleft -= fracrowtofill;
196	if ( fracrowleft == 0 ) {
197	fracrowleft = syscale;
198	needtoreadrow = 1;
199	}
200	fracrowtofill = SCALE;
201	}
202
203	/* Now scale X from tempxelrow into dst and write it out. */
204	if ( newcols == cols ) {
205	/* shortcut X scaling if possible */
206	memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4);
207	} else {
208	long a, r, g, b;
209	long fraccoltofill, fraccolleft = 0;
210	int needcol;
211
212	nxP = (TQRgb*)dst.scanLine(rowswritten++);
213	colswritten = 0;
214	fraccoltofill = SCALE;
215	a = r = g = b = HALFSCALE;
216	needcol = 0;
217	for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP ) {
218	fraccolleft = sxscale;
219	while ( fraccolleft >= fraccoltofill ) {
220	if ( needcol ) {
221	++nxP;
222	++colswritten;
223	a = r = g = b = HALFSCALE;
224	}
225	if ((colswritten >= x) && (colswritten <= (x + w)) && (rowswritten >= y) && (rowswritten <= (y + h))) {
226	if ( as ) {
227	r += fraccoltofill * tqRed( xP ) tqAlpha( *xP ) / 255;
228	g += fraccoltofill * tqGreen( xP ) tqAlpha( *xP ) / 255;
229	b += fraccoltofill * tqBlue( xP ) tqAlpha( *xP ) / 255;
230	a += fraccoltofill * tqAlpha( *xP );
231	if ( a ) {
232	r = r * 255 / a * SCALE;
233	g = g * 255 / a * SCALE;
234	b = b * 255 / a * SCALE;
235	}
236	} else {
237	r += fraccoltofill * tqRed( *xP );
238	g += fraccoltofill * tqGreen( *xP );
239	b += fraccoltofill * tqBlue( *xP );
240	}
241	r /= SCALE;
242	if ( r > maxval ) r = maxval;
243	g /= SCALE;
244	if ( g > maxval ) g = maxval;
245	b /= SCALE;
246	if ( b > maxval ) b = maxval;
247	if (as) {
248	a /= SCALE;
249	if ( a > maxval ) a = maxval;
250	*nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
251	} else {
252	*nxP = tqRgb( (int)r, (int)g, (int)b );
253	}
254	}
255	fraccolleft -= fraccoltofill;
256	fraccoltofill = SCALE;
257	needcol = 1;
258	}
259	if ( fraccolleft > 0 ) {
260	if ( needcol ) {
261	++nxP;
262	++colswritten;
263	a = r = g = b = HALFSCALE;
264	needcol = 0;
265	}
266	if ((rowswritten >= y) && (rowswritten <= (y + h))) {
267	if (as) {
268	a += fraccolleft * tqAlpha( *xP );
269	r += fraccolleft * tqRed( xP ) tqAlpha( *xP ) / 255;
270	g += fraccolleft * tqGreen( xP ) tqAlpha( *xP ) / 255;
271	b += fraccolleft * tqBlue( xP ) tqAlpha( *xP ) / 255;
272	} else {
273	r += fraccolleft * tqRed( *xP );
274	g += fraccolleft * tqGreen( *xP );
275	b += fraccolleft * tqBlue( *xP );
276	}
277	}
278	fraccoltofill -= fraccolleft;
279	}
280	}
281	if ( fraccoltofill > 0 ) {
282	--xP;
283	if ((rowswritten >= y) && (rowswritten <= (y + h))) {
284	if (as) {
285	a += fraccolleft * tqAlpha( *xP );
286	r += fraccoltofill * tqRed( xP ) tqAlpha( *xP ) / 255;
287	g += fraccoltofill * tqGreen( xP ) tqAlpha( *xP ) / 255;
288	b += fraccoltofill * tqBlue( xP ) tqAlpha( *xP ) / 255;
289	if ( a ) {
290	r = r * 255 / a * SCALE;
291	g = g * 255 / a * SCALE;
292	b = b * 255 / a * SCALE;
293	}
294	} else {
295	r += fraccoltofill * tqRed( *xP );
296	g += fraccoltofill * tqGreen( *xP );
297	b += fraccoltofill * tqBlue( *xP );
298	}
299	}
300	}
301	if ( ! needcol ) {
302	if ((rowswritten >= y) && (rowswritten <= (y + h))) {
303	r /= SCALE;
304	if ( r > maxval ) r = maxval;
305	g /= SCALE;
306	if ( g > maxval ) g = maxval;
307	b /= SCALE;
308	if ( b > maxval ) b = maxval;
309	if (as) {
310	a /= SCALE;
311	if ( a > maxval ) a = maxval;
312	*nxP = tqRgba( (int)r, (int)g, (int)b, (int)a );
313	} else {
314	*nxP = tqRgb( (int)r, (int)g, (int)b );
315	}
316	}
317	}
318	}
319	}
320
321	if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
322	delete [] tempxelrow;
323	if ( as ) // Avoid purify complaint
324	delete [] as;
325	if ( rs ) // Robust, rs might be 0 one day
326	delete [] rs;
327	if ( gs ) // Robust, gs might be 0 one day
328	delete [] gs;
329	if ( bs ) // Robust, bs might be 0 one day
330	delete [] bs;
331	}

Lines 2-9 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.h (-47 / +59 lines)
2	threads.h - threads for kvncview	2	threads.h - threads for kvncview
3	-------------------	3	-------------------
4	begin : Thu May 09 16:01:42 CET 2002	4	begin : Thu May 09 16:01:42 CET 2002
5	copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net>	5	copyright : (C) 2002 by Tim Jansen
6	(C) 2002 by Tim Jansen
7	email : tim@tjansen.de	6	email : tim@tjansen.de
8	***************************************************************************/	7	***************************************************************************/
9		8
Lines 27-41 Link Here
27	#include <tqevent.h>	26	#include <tqevent.h>
28	#include <tqvaluelist.h>	27	#include <tqvaluelist.h>
29	#include <tqdatetime.h>	28	#include <tqdatetime.h>
30	#include <tqimage.h>
31		29
32	#include <stdlib.h>	30	#include <stdlib.h>
33		31
34	#include "events.h"	32	#include "events.h"
35		33	#include "vnctypes.h"
36	extern "C" {
37	#include <rfb/rfbclient.h>
38	}
39		34
40	class KVncView;	35	class KVncView;
41		36
Lines 62-112 Link Here
62	} e;	57	} e;
63	};	58	};
64		59
65	class ControllerThreadObject : public TQObject {
66	TQ_OBJECT
67
68	public:
69	ControllerThreadObject(KVncView *v, volatile bool &quitFlag);
70	~ControllerThreadObject();
71
72	enum RemoteViewStatus status();
73		60
74	void setImage(const TQImage &img);	61	class WriterThread : public TQThread {
75	const TQImage image(int x = 0, int y = 0, int w = 0, int h = 0);	62	private:
76	void authenticationResults(int resultCode);	63	TQMutex m_lock;
77	void networkStatus(int statusCode);	64	TQWaitCondition m_waiter;
		65	volatile bool &m_quitFlag;
		66	KVncView *m_view;
		67
		68	TQTime m_lastIncrUpdate; // start()ed when a incr update is sent
		69	bool m_lastIncrUpdatePostponed;
		70
		71	// all things that can be send follow:
		72	bool m_incrementalUpdateRQ; // for sending an incremental request
		73	bool m_incrementalUpdateAnnounced; // set when a RQ will come soon
		74	TQRegion m_updateRegionRQ; // for sending updates, null if it is done
		75	TQValueList<InputEvent> m_inputEvents; // list of unsent input events
		76	MouseEvent m_lastMouseEvent;
		77	int m_mouseEventNum, m_keyEventNum;
		78	TQString m_clientCut;
78		79
79	void setScaling(int w, int h);	80	void sendFatalError(ErrorCode s);
80	void queueDrawRegion(int x, int y, int w, int h);
81		81
82	rfbClient *cl;	82	public:
83		83	WriterThread(KVncView *v, volatile bool &quitFlag);
84	public slots:
85	void run();
86
87	public:
88	void queueMouseEvent(int x, int y, int buttonMask);
89	void queueKeyEvent(unsigned int k, bool down);
90	void queueClientCut(const TQString &text);
91
92	private:
93	KVncView *m_view;
94	TQImage m_image;
95	TQImage m_scaledImage;
96	TQMutex mutex;
97	enum RemoteViewStatus m_status;
98	volatile bool &m_quitFlag;
99
100	bool m_scaling;
101	int m_scalingWidth;
102	int m_scalingHeight;
103	bool m_resizeEntireFrame;
104		84
105	// all things that can be send follow:	85	void queueIncrementalUpdateRequest();
106	TQValueList<InputEvent> m_inputEvents; // list of unsent input events	86	void announceIncrementalUpdateRequest();
		87	void queueUpdateRequest(const TQRegion &r);
		88	void queueMouseEvent(int x, int y, int buttonMask);
		89	void queueKeyEvent(unsigned int k, bool down);
		90	void queueClientCut(const TQString &text);
		91	void kick();
107		92
108	void changeStatus(RemoteViewStatus s);	93	protected:
109	void sendFatalError(ErrorCode s);	94	void run();
		95	bool sendIncrementalUpdateRequest();
		96	bool sendUpdateRequest(const TQRegion &r);
		97	bool sendInputEvents(const TQValueList<InputEvent> &events);
		98	};
		99
		100
		101
		102	class ControllerThread : public TQThread {
		103	private:
		104	KVncView *m_view;
		105	enum RemoteViewStatus m_status;
		106	WriterThread &m_wthread;
		107	volatile bool &m_quitFlag;
		108	volatile bool m_desktopInitialized;
		109	TQWaitCondition m_waiter;
		110
		111	void changeStatus(RemoteViewStatus s);
		112	void sendFatalError(ErrorCode s);
		113
		114	public:
		115	ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag);
		116	enum RemoteViewStatus status();
		117	void desktopInit();
		118	void kick();
		119
		120	protected:
		121	void run();
110	};	122	};
111		123
112		124

Line 0 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/tight.c (+610 lines)
		1	/*
		2	* Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved.
		3	*
		4	* This is free software; you can redistribute it and/or modify
		5	* it under the terms of the GNU General Public License as published by
		6	* the Free Software Foundation; either version 2 of the License, or
		7	* (at your option) any later version.
		8	*
		9	* This software is distributed in the hope that it will be useful,
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	* GNU General Public License for more details.
		13	*
		14	* You should have received a copy of the GNU General Public License
		15	* along with this software; if not, write to the Free Software
		16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
		17	* USA.
		18	*/
		19
		20	/*
		21	* tight.c - handle ``tight'' encoding.
		22	*
		23	* This file shouldn't be compiled directly. It is included multiple
		24	* times by rfbproto.c, each time with a different definition of the
		25	* macro BPP. For each value of BPP, this file defines a function
		26	* which handles a tight-encoded rectangle with BPP bits per pixel.
		27	*
		28	*/
		29
		30	#define TIGHT_MIN_TO_COMPRESS 12
		31
		32	#define CARDBPP CONCAT2E(CARD,BPP)
		33	#define filterPtrBPP CONCAT2E(filterPtr,BPP)
		34
		35	#define HandleTightBPP CONCAT2E(HandleTight,BPP)
		36	#define InitFilterCopyBPP CONCAT2E(InitFilterCopy,BPP)
		37	#define InitFilterPaletteBPP CONCAT2E(InitFilterPalette,BPP)
		38	#define InitFilterGradientBPP CONCAT2E(InitFilterGradient,BPP)
		39	#define FilterCopyBPP CONCAT2E(FilterCopy,BPP)
		40	#define FilterPaletteBPP CONCAT2E(FilterPalette,BPP)
		41	#define FilterGradientBPP CONCAT2E(FilterGradient,BPP)
		42	#define FillRectangleBPP CONCAT2E(FillRectangle,BPP)
		43
		44	#if BPP != 8
		45	#define DecompressJpegRectBPP CONCAT2E(DecompressJpegRect,BPP)
		46	#endif
		47
		48	#ifndef RGB_TO_PIXEL
		49
		50	#define RGB_TO_PIXEL(bpp,r,g,b) \
		51	(((CARD##bpp)(r) & myFormat.redMax) << myFormat.redShift \| \
		52	((CARD##bpp)(g) & myFormat.greenMax) << myFormat.greenShift \| \
		53	((CARD##bpp)(b) & myFormat.blueMax) << myFormat.blueShift)
		54
		55	#define RGB24_TO_PIXEL(bpp,r,g,b) \
		56	((((CARD##bpp)(r) & 0xFF) * myFormat.redMax + 127) / 255 \
		57	<< myFormat.redShift \| \
		58	(((CARD##bpp)(g) & 0xFF) * myFormat.greenMax + 127) / 255 \
		59	<< myFormat.greenShift \| \
		60	(((CARD##bpp)(b) & 0xFF) * myFormat.blueMax + 127) / 255 \
		61	<< myFormat.blueShift)
		62
		63	#define RGB24_TO_PIXEL32(r,g,b) \
		64	(((CARD32)(r) & 0xFF) << myFormat.redShift \| \
65	((CARD32)(g) & 0xFF) << myFormat.greenShift \| \
66	((CARD32)(b) & 0xFF) << myFormat.blueShift)
67
68	#endif
69
70	/* Type declarations */
71
72	typedef void (filterPtrBPP)(int, CARDBPP );
73
74	/* Prototypes */
75
76	static int InitFilterCopyBPP (int rw, int rh);
77	static int InitFilterPaletteBPP (int rw, int rh);
78	static int InitFilterGradientBPP (int rw, int rh);
79	static void FilterCopyBPP (int numRows, CARDBPP *destBuffer);
80	static void FilterPaletteBPP (int numRows, CARDBPP *destBuffer);
81	static void FilterGradientBPP (int numRows, CARDBPP *destBuffer);
82
83	static Bool DecompressJpegRectBPP(int x, int y, int w, int h);
84
85	/* Definitions */
86
87	static Bool
88	HandleTightBPP (int rx, int ry, int rw, int rh)
89	{
90	CARDBPP fill_colour;
91	XGCValues gcv;
92	CARD8 comp_ctl;
93	CARD8 filter_id;
94	filterPtrBPP filterFn;
95	z_streamp zs;
96	char *buffer2;
97	int err, stream_id, compressedLen, bitsPixel;
98	int bufferSize, rowSize, numRows, portionLen, rowsProcessed, extraBytes;
99	CARDBPP *rawData;
100
101	if (!ReadFromRFBServer((char *)&comp_ctl, 1))
102	return False;
103
104	/* Flush zlib streams if we are told by the server to do so. */
105	for (stream_id = 0; stream_id < 4; stream_id++) {
106	if ((comp_ctl & 1) && zlibStreamActive[stream_id]) {
107	if (inflateEnd (&zlibStream[stream_id]) != Z_OK &&
108	zlibStream[stream_id].msg != NULL)
109	fprintf(stderr, "inflateEnd: %s\n", zlibStream[stream_id].msg);
110	zlibStreamActive[stream_id] = False;
111	}
112	comp_ctl >>= 1;
113	}
114
115	/* Handle solid rectangles. */
116	if (comp_ctl == rfbTightFill) {
117	#if BPP == 32
118	if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
119	myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
120	if (!ReadFromRFBServer(buffer, 3))
121	return False;
122	fill_colour = RGB24_TO_PIXEL32(buffer[0], buffer[1], buffer[2]);
123	} else {
124	if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour)))
125	return False;
126	}
127	#else
128	if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour)))
129	return False;
130	#endif
131
132	LockFramebuffer();
133	FillRectangleBPP(fill_colour, rx, ry, rw, rh);
134	UnlockFramebuffer();
135	SyncScreenRegion(rx, ry, rw, rh);
136	return True;
137	}
138
139	#if BPP == 8
140	if (comp_ctl == rfbTightJpeg) {
141	fprintf(stderr, "Tight encoding: JPEG is not supported in 8 bpp mode.\n");
142	return False;
143	}
144	#else
145	if (comp_ctl == rfbTightJpeg) {
146	return DecompressJpegRectBPP(rx, ry, rw, rh);
147	}
148	#endif
149
150	/* Quit on unsupported subencoding value. */
151	if (comp_ctl > rfbTightMaxSubencoding) {
152	fprintf(stderr, "Tight encoding: bad subencoding value received.\n");
153	return False;
154	}
155
156	/*
157	* Here primary compression mode handling begins.
158	* Data was processed with optional filter + zlib compression.
159	*/
160
161	/* First, we should identify a filter to use. */
162	if ((comp_ctl & rfbTightExplicitFilter) != 0) {
163	if (!ReadFromRFBServer((char*)&filter_id, 1))
164	return False;
165
166	switch (filter_id) {
167	case rfbTightFilterCopy:
168	filterFn = FilterCopyBPP;
169	bitsPixel = InitFilterCopyBPP(rw, rh);
170	break;
171	case rfbTightFilterPalette:
172	filterFn = FilterPaletteBPP;
173	bitsPixel = InitFilterPaletteBPP(rw, rh);
174	break;
175	case rfbTightFilterGradient:
176	filterFn = FilterGradientBPP;
177	bitsPixel = InitFilterGradientBPP(rw, rh);
178	break;
179	default:
180	fprintf(stderr, "Tight encoding: unknown filter code received.\n");
181	return False;
182	}
183	} else {
184	filterFn = FilterCopyBPP;
185	bitsPixel = InitFilterCopyBPP(rw, rh);
186	}
187	if (bitsPixel == 0) {
188	fprintf(stderr, "Tight encoding: error receiving palette.\n");
189	return False;
190	}
191
192	/* Determine if the data should be decompressed or just copied. */
193	rowSize = (rw * bitsPixel + 7) / 8;
194	if (rh * rowSize < TIGHT_MIN_TO_COMPRESS) {
195	if (!ReadFromRFBServer((char)buffer, rh rowSize))
196	return False;
197
198	buffer2 = &buffer[TIGHT_MIN_TO_COMPRESS * 4];
199	filterFn(rh, (CARDBPP *)buffer2);
200	CopyDataToScreen(buffer2, rx, ry, rw, rh);
201
202	return True;
203	}
204
205	/* Read the length (1..3 bytes) of compressed data following. */
206	compressedLen = (int)ReadCompactLen();
207	if (compressedLen <= 0) {
208	fprintf(stderr, "Incorrect data received from the server.\n");
209	return False;
210	}
211
212	/* Now let's initialize compression stream if needed. */
213	stream_id = comp_ctl & 0x03;
214	zs = &zlibStream[stream_id];
215	if (!zlibStreamActive[stream_id]) {
216	zs->zalloc = Z_NULL;
217	zs->zfree = Z_NULL;
218	zs->opaque = Z_NULL;
219	err = inflateInit(zs);
220	if (err != Z_OK) {
221	if (zs->msg != NULL)
222	fprintf(stderr, "InflateInit error: %s.\n", zs->msg);
223	return False;
224	}
225	zlibStreamActive[stream_id] = True;
226	}
227
228	/* Read, decode and draw actual pixel data in a loop. */
229
230	bufferSize = BUFFER_SIZE * bitsPixel / (bitsPixel + BPP) & 0xFFFFFFFC;
231	buffer2 = &buffer[bufferSize];
232	if (rowSize > bufferSize) {
233	/* Should be impossible when BUFFER_SIZE >= 16384 */
234	fprintf(stderr, "Internal error: incorrect buffer size.\n");
235	return False;
236	}
237
238	rowsProcessed = 0;
239	extraBytes = 0;
240
241	while (compressedLen > 0) {
242	if (compressedLen > ZLIB_BUFFER_SIZE)
243	portionLen = ZLIB_BUFFER_SIZE;
244	else
245	portionLen = compressedLen;
246
247	if (!ReadFromRFBServer((char*)zlib_buffer, portionLen))
248	return False;
249
250	compressedLen -= portionLen;
251
252	zs->next_in = (Bytef *)zlib_buffer;
253	zs->avail_in = portionLen;
254
255	do {
256	zs->next_out = (Bytef *)&buffer[extraBytes];
257	zs->avail_out = bufferSize - extraBytes;
258
259	err = inflate(zs, Z_SYNC_FLUSH);
260	if (err == Z_BUF_ERROR) /* Input exhausted -- no problem. */
261	break;
262	if (err != Z_OK && err != Z_STREAM_END) {
263	if (zs->msg != NULL) {
264	fprintf(stderr, "Inflate error: %s.\n", zs->msg);
265	} else {
266	fprintf(stderr, "Inflate error: %d.\n", err);
267	}
268	return False;
269	}
270
271	numRows = (bufferSize - zs->avail_out) / rowSize;
272
273	filterFn(numRows, (CARDBPP *)buffer2);
274
275	extraBytes = bufferSize - zs->avail_out - numRows * rowSize;
276	if (extraBytes > 0)
277	memcpy(buffer, &buffer[numRows * rowSize], extraBytes);
278
279	CopyDataToScreen(buffer2, rx, ry + rowsProcessed, rw, numRows);
280	rowsProcessed += numRows;
281	}
282	while (zs->avail_out == 0);
283	}
284
285	if (rowsProcessed != rh) {
286	fprintf(stderr, "Incorrect number of scan lines after decompression.\n");
287	return False;
288	}
289
290	return True;
291	}
292
293	/*----------------------------------------------------------------------------
294	*
295	* Filter stuff.
296	*
297	*/
298
299	/*
300	The following variables are defined in rfbproto.c:
301	static Bool cutZeros;
302	static int rectWidth, rectColors;
303	static CARD8 tightPalette[256*4];
304	static CARD8 tightPrevRow[20483sizeof(CARD16)];
305	*/
306
307	static int
308	InitFilterCopyBPP (int rw, int rh)
309	{
310	rectWidth = rw;
311
312	#if BPP == 32
313	if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
314	myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
315	cutZeros = True;
316	return 24;
317	} else {
318	cutZeros = False;
319	}
320	#endif
321
322	return BPP;
323	}
324
325	static void
326	FilterCopyBPP (int numRows, CARDBPP *dst)
327	{
328
329	#if BPP == 32
330	int x, y;
331
332	if (cutZeros) {
333	for (y = 0; y < numRows; y++) {
334	for (x = 0; x < rectWidth; x++) {
335	dst[y*rectWidth+x] =
336	RGB24_TO_PIXEL32(buffer[(yrectWidth+x)3],
337	buffer[(yrectWidth+x)3+1],
338	buffer[(yrectWidth+x)3+2]);
339	}
340	}
341	return;
342	}
343	#endif
344
345	memcpy (dst, buffer, numRows * rectWidth * (BPP / 8));
346	}
347
348	static int
349	InitFilterGradientBPP (int rw, int rh)
350	{
351	int bits;
352
353	bits = InitFilterCopyBPP(rw, rh);
354	if (cutZeros)
355	memset(tightPrevRow, 0, rw * 3);
356	else
357	memset(tightPrevRow, 0, rw * 3 * sizeof(CARD16));
358
359	return bits;
360	}
361
362	#if BPP == 32
363
364	static void
365	FilterGradient24 (int numRows, CARD32 *dst)
366	{
367	int x, y, c;
368	CARD8 thisRow[2048*3];
369	CARD8 pix[3];
370	int est[3];
371
372	for (y = 0; y < numRows; y++) {
373
374	/* First pixel in a row */
375	for (c = 0; c < 3; c++) {
376	pix[c] = tightPrevRow[c] + buffer[yrectWidth3+c];
377	thisRow[c] = pix[c];
378	}
379	dst[y*rectWidth] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
380
381	/* Remaining pixels of a row */
382	for (x = 1; x < rectWidth; x++) {
383	for (c = 0; c < 3; c++) {
384	est[c] = (int)tightPrevRow[x*3+c] + (int)pix[c] -
385	(int)tightPrevRow[(x-1)*3+c];
386	if (est[c] > 0xFF) {
387	est[c] = 0xFF;
388	} else if (est[c] < 0x00) {
389	est[c] = 0x00;
390	}
391	pix[c] = (CARD8)est[c] + buffer[(yrectWidth+x)3+c];
392	thisRow[x*3+c] = pix[c];
393	}
394	dst[y*rectWidth+x] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
395	}
396
397	memcpy(tightPrevRow, thisRow, rectWidth * 3);
398	}
399	}
400
401	#endif
402
403	static void
404	FilterGradientBPP (int numRows, CARDBPP *dst)
405	{
406	int x, y, c;
407	CARDBPP src = (CARDBPP )buffer;
408	CARD16 thatRow = (CARD16 )tightPrevRow;
409	CARD16 thisRow[2048*3];
410	CARD16 pix[3];
411	CARD16 max[3];
412	int shift[3];
413	int est[3];
414
415	#if BPP == 32
416	if (cutZeros) {
417	FilterGradient24(numRows, dst);
418	return;
419	}
420	#endif
421
422	max[0] = myFormat.redMax;
423	max[1] = myFormat.greenMax;
424	max[2] = myFormat.blueMax;
425
426	shift[0] = myFormat.redShift;
427	shift[1] = myFormat.greenShift;
428	shift[2] = myFormat.blueShift;
429
430	for (y = 0; y < numRows; y++) {
431
432	/* First pixel in a row */
433	for (c = 0; c < 3; c++) {
434	pix[c] = (CARD16)((src[y*rectWidth] >> shift[c]) + thatRow[c] & max[c]);
435	thisRow[c] = pix[c];
436	}
437	dst[y*rectWidth] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
438
439	/* Remaining pixels of a row */
440	for (x = 1; x < rectWidth; x++) {
441	for (c = 0; c < 3; c++) {
442	est[c] = (int)thatRow[x3+c] + (int)pix[c] - (int)thatRow[(x-1)3+c];
443	if (est[c] > (int)max[c]) {
444	est[c] = (int)max[c];
445	} else if (est[c] < 0) {
446	est[c] = 0;
447	}
448	pix[c] = (CARD16)((src[y*rectWidth+x] >> shift[c]) + est[c] & max[c]);
449	thisRow[x*3+c] = pix[c];
450	}
451	dst[y*rectWidth+x] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
452	}
453	memcpy(thatRow, thisRow, rectWidth * 3 * sizeof(CARD16));
454	}
455	}
456
457	static int
458	InitFilterPaletteBPP (int rw, int rh)
459	{
460	int i;
461	CARD8 numColors;
462	CARDBPP palette = (CARDBPP )tightPalette;
463
464	rectWidth = rw;
465
466	if (!ReadFromRFBServer((char*)&numColors, 1))
467	return 0;
468
469	rectColors = (int)numColors;
470	if (++rectColors < 2)
471	return 0;
472
473	#if BPP == 32
474	if (myFormat.depth == 24 && myFormat.redMax == 0xFF &&
475	myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) {
476	if (!ReadFromRFBServer((char)&tightPalette, rectColors 3))
477	return 0;
478	for (i = rectColors - 1; i >= 0; i--) {
479	palette[i] = RGB24_TO_PIXEL32(tightPalette[i*3],
480	tightPalette[i*3+1],
481	tightPalette[i*3+2]);
482	}
483	return (rectColors == 2) ? 1 : 8;
484	}
485	#endif
486
487	if (!ReadFromRFBServer((char)&tightPalette, rectColors (BPP / 8)))
488	return 0;
489
490	return (rectColors == 2) ? 1 : 8;
491	}
492
493	static void
494	FilterPaletteBPP (int numRows, CARDBPP *dst)
495	{
496	int x, y, b, w;
497	CARD8 src = (CARD8 )buffer;
498	CARDBPP palette = (CARDBPP )tightPalette;
499
500	if (rectColors == 2) {
501	w = (rectWidth + 7) / 8;
502	for (y = 0; y < numRows; y++) {
503	for (x = 0; x < rectWidth / 8; x++) {
504	for (b = 7; b >= 0; b--)
505	dst[yrectWidth+x8+7-b] = palette[src[y*w+x] >> b & 1];
506	}
507	for (b = 7; b >= 8 - rectWidth % 8; b--) {
508	dst[yrectWidth+x8+7-b] = palette[src[y*w+x] >> b & 1];
509	}
510	}
511	} else {
512	for (y = 0; y < numRows; y++)
513	for (x = 0; x < rectWidth; x++)
514	dst[yrectWidth+x] = palette[(int)src[yrectWidth+x]];
515	}
516	}
517
518	#if BPP != 8
519
520	/*----------------------------------------------------------------------------
521	*
522	* JPEG decompression.
523	*
524	*/
525
526	/*
527	The following variables are defined in rfbproto.c:
528	static Bool jpegError;
529	static struct jpeg_source_mgr jpegSrcManager;
530	static JOCTET *jpegBufferPtr;
531	static size_t *jpegBufferLen;
532	*/
533
534	static Bool
535	DecompressJpegRectBPP(int x, int y, int w, int h)
536	{
537	struct jpeg_decompress_struct cinfo;
538	struct jpeg_error_mgr jerr;
539	int compressedLen;
540	CARD8 *compressedData;
541	CARDBPP *pixelPtr;
542	JSAMPROW rowPointer[1];
543	int dx, dy;
544
545	compressedLen = (int)ReadCompactLen();
546	if (compressedLen <= 0) {
547	fprintf(stderr, "Incorrect data received from the server.\n");
548	return False;
549	}
550
551	if (compressedLen > MAX_JPEG_SIZE) {
552	fprintf(stderr, "To large data announced by the server.\n");
553	return False;
554	}
555
556	compressedData = malloc(compressedLen);
557	if (compressedData == NULL) {
558	fprintf(stderr, "Memory allocation error.\n");
559	return False;
560	}
561
562	if (!ReadFromRFBServer((char*)compressedData, compressedLen)) {
563	free(compressedData);
564	return False;
565	}
566
567	cinfo.err = jpeg_std_error(&jerr);
568	jpeg_create_decompress(&cinfo);
569
570	JpegSetSrcManager(&cinfo, compressedData, compressedLen);
571
572	jpeg_read_header(&cinfo, TRUE);
573	cinfo.out_color_space = JCS_RGB;
574
575	jpeg_start_decompress(&cinfo);
576	if (cinfo.output_width != w \|\| cinfo.output_height != h \|\|
577	cinfo.output_components != 3) {
578	fprintf(stderr, "Tight Encoding: Wrong JPEG data received.\n");
579	jpeg_destroy_decompress(&cinfo);
580	free(compressedData);
581	return False;
582	}
583
584	rowPointer[0] = (JSAMPROW)buffer;
585	dy = 0;
586	while (cinfo.output_scanline < cinfo.output_height) {
587	jpeg_read_scanlines(&cinfo, rowPointer, 1);
588	if (jpegError) {
589	break;
590	}
591	pixelPtr = (CARDBPP *)&buffer[BUFFER_SIZE / 2];
592	for (dx = 0; dx < w; dx++) {
593	*pixelPtr++ =
594	RGB24_TO_PIXEL(BPP, buffer[dx3], buffer[dx3+1], buffer[dx*3+2]);
595	}
596	CopyDataToScreen(&buffer[BUFFER_SIZE / 2], x, y + dy, w, 1);
597	dy++;
598	}
599
600	if (!jpegError)
601	jpeg_finish_decompress(&cinfo);
602
603	jpeg_destroy_decompress(&cinfo);
604	free(compressedData);
605
606	return !jpegError;
607	}
608
609	#endif
610

Line 0 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vnctypes.h (+73 lines)
		1	/*
		2	* Copyright (C) 2002 Tim Jansen. All Rights Reserved.
		3	* Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved.
		4	* Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
		5	* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
		6	*
		7	* This is free software; you can redistribute it and/or modify
		8	* it under the terms of the GNU General Public License as published by
		9	* the Free Software Foundation; either version 2 of the License, or
		10	* (at your option) any later version.
		11	*
		12	* This software is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	* GNU General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU General Public License
		18	* along with this software; if not, write to the Free Software
		19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
		20	* USA.
		21	*/
		22
		23	#ifndef VNCTYPES_H
		24	#define VNCTYPES_H
		25
		26	#if(defined __cplusplus)
		27	extern "C"
		28	{
		29	#endif
		30
		31	#include <X11/Xmd.h>
		32
		33
		34	typedef struct {
		35	int shareDesktop; /* bool */
		36	int viewOnly; /* bool */
		37
		38	const char* encodingsString;
		39
		40	int useBGR233; /* bool */
		41	int nColours;
		42	int useSharedColours; /* bool */
		43	int requestedDepth;
		44
		45	int rawDelay;
		46	int copyRectDelay;
		47
		48	int debug; /* bool */
		49
		50	int compressLevel;
		51	int qualityLevel;
		52	int dotCursor; /* bool */
		53
		54	} AppData;
		55
		56
		57	enum InitStatus {
		58	INIT_OK = 0,
		59	INIT_NAME_RESOLUTION_FAILURE = 1,
		60	INIT_PROTOCOL_FAILURE = 2,
		61	INIT_CONNECTION_FAILED = 3,
		62	INIT_AUTHENTICATION_FAILED = 4,
		63	INIT_NO_SERVER = 5,
		64	INIT_SERVER_BLOCKED = 6,
65	INIT_ABORTED = 7
66	};
67
68
69	#if(defined __cplusplus)
70	}
71	#endif
72
73	#endif

Lines 36-49 Link Here

(-)tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncviewer.h (-2 / +118 lines)
36	#include <X11/keysym.h>	36	#include <X11/keysym.h>
37	#include <X11/Xatom.h>	37	#include <X11/Xatom.h>
38	#include <X11/Xmu/StdSel.h>	38	#include <X11/Xmu/StdSel.h>
		39	#include "vnctypes.h"
39		40
40	#if(defined __cplusplus)	41	#if(defined __cplusplus)
41	extern "C"	42	extern "C"
42	{	43	{
43	#endif	44	#endif
44		45
45	#include "rfb/rfbclient.h"	46	#include "rfbproto.h"
46	#include "rfb/rfbproto.h"	47
		48	extern int endianTest;
		49
		50	#define Swap16IfLE(s) \
		51	((char )&endianTest ? ((((s) & 0xff) << 8) \| (((s) >> 8) & 0xff)) : (s))
		52
		53	#define Swap32IfLE(l) \
		54	((char )&endianTest ? ((((l) & 0xff000000) >> 24) \| \
		55	(((l) & 0x00ff0000) >> 8) \| \
		56	(((l) & 0x0000ff00) << 8) \| \
		57	(((l) & 0x000000ff) << 24)) : (l))
		58
		59	#define MAX_ENCODINGS 20
		60
47		61
48	/ kvncview.cpp /	62	/ kvncview.cpp /
49		63
Lines 64-69 Link Here
64	extern void newServerCut(char *bytes, int len);	78	extern void newServerCut(char *bytes, int len);
65	extern void postMouseEvent(int x, int y, int buttonMask);	79	extern void postMouseEvent(int x, int y, int buttonMask);
66		80
		81	/ threads.cpp /
		82
		83	extern void queueIncrementalUpdateRequest();
		84	extern void announceIncrementalUpdateRequest();
		85
		86	/* colour.c */
		87
		88	extern unsigned long BGR233ToPixel[];
		89
		90	extern Colormap cmap;
		91	extern Visual *vis;
		92	extern unsigned int visdepth, visbpp;
		93
		94	extern void SetVisualAndCmap(void);
		95
		96	/* desktop.c */
		97
		98	extern Widget form, viewport, desktop;
		99	extern GC gc;
		100	extern GC srcGC, dstGC;
		101	extern Dimension dpyWidth, dpyHeight;
		102
		103	extern void DesktopInit(Window win);
		104	extern void ToplevelInit(void);
		105	extern void SendRFBEvent(XEvent event, String params, Cardinal *num_params);
		106	extern void CopyDataToScreen(char *buf, int x, int y, int width, int height);
		107	extern void CopyDataFromScreen(char *buf, int x, int y, int width, int height);
		108	extern void FillRectangle8(CARD8, int x, int y, int width, int height);
		109	extern void FillRectangle16(CARD16, int x, int y, int width, int height);
		110	extern void FillRectangle32(CARD32, int x, int y, int width, int height);
		111	extern void CopyArea(int srcX, int srcY, int width, int height, int x, int y);
		112	extern void SyncScreenRegion(int x, int y, int width, int height);
		113	extern void SyncScreenRegionX11Thread(int x, int y, int width, int height);
		114	extern void drawCursor(void);
		115	extern void DrawCursorX11Thread(int x, int y);
		116	extern void undrawCursor(void);
		117	extern void getBoundingRectCursor(int cx, int cy, int _imageIndex,
		118	int x, int y, int w, int h);
		119	extern int rectsIntersect(int x, int y, int w, int h,
		120	int x2, int y2, int w2, int h2);
		121	extern int rectContains(int outX, int outY, int outW, int outH,
		122	int inX, int inY, int inW, int inH);
		123	extern void rectsJoin(int nx1, int ny1, int nw1, int nh1,
		124	int x2, int y2, int w2, int h2);
		125	extern void DrawZoomedScreenRegionX11Thread(Window win, int zwidth,
		126	int zheight,
		127	int x, int y,
		128	int width, int height);
		129	extern void DrawScreenRegionX11Thread(Window win, int x, int y,
		130	int width, int height);
		131	extern void Cleanup(void);
		132	extern XImage *CreateShmZoomImage(void);
		133	extern XImage *CreateShmImage(void);
		134	extern void ShmCleanup(void);
		135	extern void freeDesktopResources(void);
		136
		137	/* rfbproto.c */
		138
		139	extern int rfbsock;
		140	extern Bool canUseCoRRE;
		141	extern Bool canUseHextile;
		142	extern char *desktopName;
		143	extern rfbPixelFormat myFormat;
		144	extern rfbServerInitMsg si;
145
146	extern int cursorX, cursorY;
147	extern int imageIndex;
148	typedef struct {
149	int set;
150	int w, h;
151	int hotX, hotY;
152	int len;
153	char *image;
154	} PointerImage;
155	extern PointerImage pointerImages[];
156
157	extern int ConnectToRFBServer(const char *hostname, int port);
158	extern enum InitStatus InitialiseRFBConnection(void);
159	extern Bool SetFormatAndEncodings(void);
160	extern Bool SendIncrementalFramebufferUpdateRequest(void);
161	extern Bool SendFramebufferUpdateRequest(int x, int y, int w, int h,
162	Bool incremental);
163	extern Bool SendPointerEvent(int x, int y, int buttonMask);
164	extern Bool SendKeyEvent(CARD32 key, Bool down);
165	extern Bool SendClientCutText(const char *str, int len);
166	extern Bool HandleRFBServerMessage(void);
167
168	extern void PrintPixelFormat(rfbPixelFormat *format);
169	extern void freeRFBProtoResources(void);
170	extern void freeResources(void);
171
172	/* sockets.c */
173
174	extern Bool errorMessageOnReadFailure;
175
176	extern Bool ReadFromRFBServer(char *out, unsigned int n);
177	extern Bool WriteExact(int sock, const char *buf, int n);
178	extern int ConnectToTcpAddr(unsigned int host, int port);
179
180	extern int StringToIPAddr(const char str, unsigned int addr);
181	extern void freeSocketsResources(void);
182
67	#if(defined __cplusplus)	183	#if(defined __cplusplus)
68	}	184	}
69	#endif	185	#endif