From 339d5c5986e559e69dd880375add24c0f39cdb8c Mon Sep 17 00:00:00 2001
From: Timothy Pearson <kb9vqf@pearsoncomputing.net>
Date: Mon, 8 Apr 2013 11:56:31 -0500
Subject: Use TQThread in krfb where threads interact with TQt3 instead of
 direct pthread access This resolves Bug 1403

---
 krfb/libvncserver/CMakeLists.txt |  10 +-
 krfb/libvncserver/Makefile.am    |   4 +-
 krfb/libvncserver/cursor.c       |  12 +-
 krfb/libvncserver/main.c         | 729 ------------------------------------
 krfb/libvncserver/main.cc        | 784 +++++++++++++++++++++++++++++++++++++++
 krfb/libvncserver/main.h         |  43 +++
 krfb/libvncserver/rfb.h          |  14 +-
 7 files changed, 851 insertions(+), 745 deletions(-)
 delete mode 100644 krfb/libvncserver/main.c
 create mode 100644 krfb/libvncserver/main.cc
 create mode 100644 krfb/libvncserver/main.h

diff --git a/krfb/libvncserver/CMakeLists.txt b/krfb/libvncserver/CMakeLists.txt
index 9f1009c6..fece6692 100644
--- a/krfb/libvncserver/CMakeLists.txt
+++ b/krfb/libvncserver/CMakeLists.txt
@@ -9,14 +9,20 @@
 #
 #################################################
 
+include_directories(
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+
 add_definitions( -DHAVE_PTHREADS -DALLOW24BPP )
 
 
 ##### vncserver (static) ########################
 
-tde_add_library( vncserver STATIC_PIC
+tde_add_library( vncserver STATIC_PIC AUTOMOC
   SOURCES
-    main.c rfbserver.c sraRegion.c auth.c sockets.c stats.c corre.c
+    main.cc rfbserver.c sraRegion.c auth.c sockets.c stats.c corre.c
     hextile.c rre.c translate.c cutpaste.c zlib.c tight.c httpd.c
     cursor.c font.c draw.c selbox.c d3des.c vncauth.c cargs.c
 )
diff --git a/krfb/libvncserver/Makefile.am b/krfb/libvncserver/Makefile.am
index ed8e22d2..2203dd7f 100644
--- a/krfb/libvncserver/Makefile.am
+++ b/krfb/libvncserver/Makefile.am
@@ -1,8 +1,10 @@
 INCLUDES = $(all_includes)
 
+METASOURCES = AUTO
+
 noinst_LTLIBRARIES = libvncserver.la
 
-libvncserver_la_SOURCES = main.c rfbserver.c sraRegion.c auth.c sockets.c \
+libvncserver_la_SOURCES = main.cc rfbserver.c sraRegion.c auth.c sockets.c \
 	stats.c corre.c hextile.c rre.c translate.c cutpaste.c \
 	zlib.c tight.c httpd.c cursor.c font.c \
 	draw.c selbox.c d3des.c vncauth.c cargs.c
diff --git a/krfb/libvncserver/cursor.c b/krfb/libvncserver/cursor.c
index a27a2fef..3609b18f 100644
--- a/krfb/libvncserver/cursor.c
+++ b/krfb/libvncserver/cursor.c
@@ -362,15 +362,15 @@ rfbCursorPtr rfbMakeXCursor(int width,int height,char* cursorString,char* maskSt
    cursor->source = (unsigned char*)calloc(w,height);
    for(j=0,cp=cursorString;j<height;j++)
       for(i=0,bit=0x80;i<width;i++,bit=(bit&1)?0x80:bit>>1,cp++)
-	if(*cp!=' ') cursor->source[j*w+i/8]|=bit;
+	if(*cp!=' ') ((char*)(cursor->source))[j*w+i/8]|=bit;
 
    if(maskString) {
       cursor->mask = (unsigned char*)calloc(w,height);
       for(j=0,cp=maskString;j<height;j++)
 	for(i=0,bit=0x80;i<width;i++,bit=(bit&1)?0x80:bit>>1,cp++)
-	  if(*cp!=' ') cursor->mask[j*w+i/8]|=bit;
+	  if(*cp!=' ') ((char*)(cursor->mask))[j*w+i/8]|=bit;
    } else
-     cursor->mask = (unsigned char*)rfbMakeMaskForXCursor(width,height,cursor->source);
+     cursor->mask = (unsigned char*)rfbMakeMaskForXCursor(width,height,(char*)(cursor->source));
 
    return(cursor);
 }
@@ -403,8 +403,8 @@ void rfbFreeCursor(rfbCursorPtr cursor)
    if(cursor) {
       if(cursor->richSource)
 	 free(cursor->richSource);
-      free(cursor->source);
-      free(cursor->mask);
+      free((char*)(cursor->source));
+      free((char*)(cursor->mask));
       free(cursor);
    }
    
@@ -431,7 +431,7 @@ void MakeXCursorFromRichCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor)
    for(j=0;j<cursor->height;j++)
      for(i=0,bit=0x80;i<cursor->width;i++,bit=(bit&1)?0x80:bit>>1)
        if(memcmp(cursor->richSource+j*width+i*bpp,back,bpp))
-	 cursor->source[j*w+i/8]|=bit;
+	 ((char*)(cursor->source))[j*w+i/8]|=bit;
 }
 
 void MakeRichCursorFromXCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor)
diff --git a/krfb/libvncserver/main.c b/krfb/libvncserver/main.c
deleted file mode 100644
index 207e512d..00000000
--- a/krfb/libvncserver/main.c
+++ /dev/null
@@ -1,729 +0,0 @@
-/*
- *  This file is called main.c, because it contains most of the new functions
- *  for use with LibVNCServer.
- *
- *  LibVNCServer (C) 2001 Johannes E. Schindelin <Johannes.Schindelin@gmx.de>
- *  Original OSXvnc (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
- *  Original Xvnc (C) 1999 AT&T Laboratories Cambridge.
- *  All Rights Reserved.
- *
- *  see GPL (latest version) for full details
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <errno.h>
-
-#ifndef false
-#define false 0
-#define true -1
-#endif
-
-#include <sys/types.h>
-#ifdef __osf__
-typedef int socklen_t;
-#endif
-#ifndef WIN32
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#endif
-#include <signal.h>
-#include <time.h>
-
-#include "rfb.h"
-#include "sraRegion.h"
-
-/* minimum interval between attempts to send something */
-#define PING_MS 10000
-
-MUTEX(logMutex);
-
-int rfbEnableLogging=1;
-
-/* we cannot compare to _LITTLE_ENDIAN, because some systems
-   (as Solaris) assume little endian if _LITTLE_ENDIAN is
-   defined, even if _BYTE_ORDER is not _LITTLE_ENDIAN */
-char rfbEndianTest = (_BYTE_ORDER == 1234);
-
-/* from rfbserver.c */
-void rfbIncrClientRef(rfbClientPtr cl);
-void rfbDecrClientRef(rfbClientPtr cl);
-
-void rfbLogEnable(int enabled) {
-  rfbEnableLogging=enabled;
-}
-
-/*
- * rfbLog prints a time-stamped message to the log file (stderr).
- */
-
-void
-rfbLog(const char *format, ...)
-{
-    va_list args;
-    char buf[256];
-    time_t log_clock;
-
-    if(!rfbEnableLogging)
-      return;
-
-    LOCK(logMutex);
-    va_start(args, format);
-
-    time(&log_clock);
-    strftime(buf, 255, "%d/%m/%Y %T ", localtime(&log_clock));
-    fprintf(stderr, "%s", buf);
-
-    vfprintf(stderr, format, args);
-    fflush(stderr);
-
-    va_end(args);
-    UNLOCK(logMutex);
-}
-
-void rfbLogPerror(const char *str)
-{
-    rfbLog("%s: %s\n", str, strerror(errno));
-}
-
-void rfbScheduleCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy)
-{
-   rfbClientIteratorPtr iterator;
-   rfbClientPtr cl;
-
-   rfbUndrawCursor(rfbScreen);
-
-   iterator=rfbGetClientIterator(rfbScreen);
-   while((cl=rfbClientIteratorNext(iterator))) {
-     LOCK(cl->updateMutex);
-     if(cl->useCopyRect) {
-       sraRegionPtr modifiedRegionBackup;
-       if(!sraRgnEmpty(cl->copyRegion)) {
-	  if(cl->copyDX!=dx || cl->copyDY!=dy) {
-	     /* if a copyRegion was not yet executed, treat it as a
-	      * modifiedRegion. The idea: in this case it could be
-	      * source of the new copyRect or modified anyway. */
-	     sraRgnOr(cl->modifiedRegion,cl->copyRegion);
-	     sraRgnMakeEmpty(cl->copyRegion);
-	  } else {
-	     /* we have to set the intersection of the source of the copy
-	      * and the old copy to modified. */
-	     modifiedRegionBackup=sraRgnCreateRgn(copyRegion);
-	     sraRgnOffset(modifiedRegionBackup,-dx,-dy);
-	     sraRgnAnd(modifiedRegionBackup,cl->copyRegion);
-	     sraRgnOr(cl->modifiedRegion,modifiedRegionBackup);
-	     sraRgnDestroy(modifiedRegionBackup);
-	  }
-       }
-
-       sraRgnOr(cl->copyRegion,copyRegion);
-       cl->copyDX = dx;
-       cl->copyDY = dy;
-
-       /* if there were modified regions, which are now copied,
-	* mark them as modified, because the source of these can be overlapped
-	* either by new modified or now copied regions. */
-       modifiedRegionBackup=sraRgnCreateRgn(cl->modifiedRegion);
-       sraRgnOffset(modifiedRegionBackup,dx,dy);
-       sraRgnAnd(modifiedRegionBackup,cl->copyRegion);
-       sraRgnOr(cl->modifiedRegion,modifiedRegionBackup);
-       sraRgnDestroy(modifiedRegionBackup);
-
-#if 0
-//TODO: is this needed? Or does it mess up deferring?
-       /* while(!sraRgnEmpty(cl->copyRegion)) */ {
-#ifdef HAVE_PTHREADS
-	 if(!cl->screen->backgroundLoop)
-#endif
-	   {
-	     sraRegionPtr updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
-	     sraRgnOr(updateRegion,cl->copyRegion);
-	     UNLOCK(cl->updateMutex);
-	     rfbSendFramebufferUpdate(cl,updateRegion);
-	     sraRgnDestroy(updateRegion);
-	     continue;
-	   }
-       }
-#endif
-     } else {
-       sraRgnOr(cl->modifiedRegion,copyRegion);
-     }
-     TSIGNAL(cl->updateCond);
-     UNLOCK(cl->updateMutex);
-   }
-
-   rfbReleaseClientIterator(iterator);
-}
-
-void rfbDoCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy)
-{
-   sraRectangleIterator* i;
-   sraRect rect;
-   int j,widthInBytes,bpp=rfbScreen->rfbServerFormat.bitsPerPixel/8,
-    rowstride=rfbScreen->paddedWidthInBytes;
-   char *in,*out;
-
-   rfbUndrawCursor(rfbScreen);
-
-   /* copy it, really */
-   i = sraRgnGetReverseIterator(copyRegion,dx<0,dy<0);
-   while(sraRgnIteratorNext(i,&rect)) {
-     widthInBytes = (rect.x2-rect.x1)*bpp;
-     out = rfbScreen->frameBuffer+rect.x1*bpp+rect.y1*rowstride;
-     in = rfbScreen->frameBuffer+(rect.x1-dx)*bpp+(rect.y1-dy)*rowstride;
-     if(dy<0)
-       for(j=rect.y1;j<rect.y2;j++,out+=rowstride,in+=rowstride)
-	 memmove(out,in,widthInBytes);
-     else {
-       out += rowstride*(rect.y2-rect.y1-1);
-       in += rowstride*(rect.y2-rect.y1-1);
-       for(j=rect.y2-1;j>=rect.y1;j--,out-=rowstride,in-=rowstride)
-	 memmove(out,in,widthInBytes);
-     }
-   }
-
-   rfbScheduleCopyRegion(rfbScreen,copyRegion,dx,dy);
-}
-
-void rfbDoCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy)
-{
-  sraRegionPtr region = sraRgnCreateRect(x1,y1,x2,y2);
-  rfbDoCopyRegion(rfbScreen,region,dx,dy);
-}
-
-void rfbScheduleCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy)
-{
-  sraRegionPtr region = sraRgnCreateRect(x1,y1,x2,y2);
-  rfbScheduleCopyRegion(rfbScreen,region,dx,dy);
-}
-
-void rfbMarkRegionAsModified(rfbScreenInfoPtr rfbScreen,sraRegionPtr modRegion)
-{
-   rfbClientIteratorPtr iterator;
-   rfbClientPtr cl;
-
-   iterator=rfbGetClientIterator(rfbScreen);
-   while((cl=rfbClientIteratorNext(iterator))) {
-     LOCK(cl->updateMutex);
-     sraRgnOr(cl->modifiedRegion,modRegion);
-     TSIGNAL(cl->updateCond);
-     UNLOCK(cl->updateMutex);
-   }
-
-   rfbReleaseClientIterator(iterator);
-}
-
-void rfbMarkRectAsModified(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2)
-{
-   sraRegionPtr region;
-   int i;
-
-   if(x1>x2) { i=x1; x1=x2; x2=i; }
-   if(x1<0) x1=0;
-   if(x2>=rfbScreen->width) x2=rfbScreen->width-1;
-   if(x1==x2) return;
-
-   if(y1>y2) { i=y1; y1=y2; y2=i; }
-   if(y1<0) y1=0;
-   if(y2>=rfbScreen->height) y2=rfbScreen->height-1;
-   if(y1==y2) return;
-
-   region = sraRgnCreateRect(x1,y1,x2,y2);
-   rfbMarkRegionAsModified(rfbScreen,region);
-   sraRgnDestroy(region);
-}
-
-#ifdef HAVE_PTHREADS
-static void *
-clientOutput(void *data)
-{
-    rfbClientPtr cl = (rfbClientPtr)data;
-    Bool haveUpdate;
-    sraRegion* updateRegion;
-
-    while (1) {
-        haveUpdate = false;
-        while (!haveUpdate) {
-            if (cl->sock == -1) {
-                /* Client has disconnected. */
-                return NULL;
-            }
-	    LOCK(cl->updateMutex);
-	    haveUpdate = FB_UPDATE_PENDING(cl);
-	    if(!haveUpdate) {
-		updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
-		haveUpdate = sraRgnAnd(updateRegion,cl->requestedRegion);
-		sraRgnDestroy(updateRegion);
-	    }
-	    UNLOCK(cl->updateMutex);
-
-            if (!haveUpdate) {
-                LOCK(cl->updateMutex);
-                TIMEDWAIT(cl->updateCond, cl->updateMutex, PING_MS);
-		UNLOCK(cl->updateMutex); /* we really needn't lock now. */
-		if (!haveUpdate)
-		    rfbSendPing(cl);
-            }
-        }
-
-        /* OK, now, to save bandwidth, wait a little while for more
-           updates to come along. */
-        usleep(cl->screen->rfbDeferUpdateTime * 1000);
-
-        /* Now, get the region we're going to update, and remove
-           it from cl->modifiedRegion _before_ we send the update.
-           That way, if anything that overlaps the region we're sending
-           is updated, we'll be sure to do another update later. */
-        LOCK(cl->updateMutex);
-	updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
-        UNLOCK(cl->updateMutex);
-
-        /* Now actually send the update. */
-	rfbIncrClientRef(cl);
-        rfbSendFramebufferUpdate(cl, updateRegion);
-	rfbDecrClientRef(cl);
-
-	sraRgnDestroy(updateRegion);
-    }
-
-    return NULL;
-}
-
-static void *
-clientInput(void *data)
-{
-    rfbClientPtr cl = (rfbClientPtr)data;
-    pthread_t output_thread;
-    pthread_create(&output_thread, NULL, clientOutput, (void *)cl);
-
-    while (1) {
-        rfbProcessClientMessage(cl);
-        if (cl->sock == -1) {
-            /* Client has disconnected. */
-            break;
-        }
-    }
-
-    /* Get rid of the output thread. */
-    LOCK(cl->updateMutex);
-    TSIGNAL(cl->updateCond);
-    UNLOCK(cl->updateMutex);
-    IF_PTHREADS(pthread_join(output_thread, NULL));
-
-    rfbClientConnectionGone(cl);
-
-    return NULL;
-}
-
-static void*
-listenerRun(void *data)
-{
-    rfbScreenInfoPtr rfbScreen=(rfbScreenInfoPtr)data;
-    int client_fd;
-    struct sockaddr_in peer;
-    rfbClientPtr cl;
-    size_t len;
-
-    if (rfbScreen->inetdSock != -1) {
-       cl = rfbNewClient(rfbScreen, rfbScreen->inetdSock);
-       if (cl && !cl->onHold)
-           rfbStartOnHoldClient(cl);
-       else if (rfbScreen->inetdDisconnectHook && !cl)
-           rfbScreen->inetdDisconnectHook();
-       return 0;
-    }
-
-    len = sizeof(peer);
-
-    /* TODO: this thread wont die by restarting the server */
-    while ((client_fd = accept(rfbScreen->rfbListenSock,
-                               (struct sockaddr*)&peer, &len)) >= 0) {
-        cl = rfbNewClient(rfbScreen,client_fd);
-        len = sizeof(peer);
-
-	if (cl && !cl->onHold )
-		rfbStartOnHoldClient(cl);
-    }
-    return NULL;
-}
-
-void
-rfbStartOnHoldClient(rfbClientPtr cl)
-{
-    pthread_create(&cl->client_thread, NULL, clientInput, (void *)cl);
-}
-
-#else
-
-void
-rfbStartOnHoldClient(rfbClientPtr cl)
-{
-	cl->onHold = FALSE;
-}
-
-#endif
-
-void
-rfbRefuseOnHoldClient(rfbClientPtr cl)
-{
-    rfbCloseClient(cl);
-    rfbClientConnectionGone(cl);
-}
-
-static void
-defaultKbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl)
-{
-}
-
-void
-defaultPtrAddEvent(int buttonMask, int x, int y, rfbClientPtr cl)
-{
-   if(x!=cl->screen->cursorX || y!=cl->screen->cursorY) {
-      cl->cursorWasMoved = TRUE;
-      if(cl->screen->cursorIsDrawn)
-	rfbUndrawCursor(cl->screen);
-      LOCK(cl->screen->cursorMutex);
-      if(!cl->screen->cursorIsDrawn) {
-	  cl->screen->cursorX = x;
-	  cl->screen->cursorY = y;
-      }
-      UNLOCK(cl->screen->cursorMutex);
-   }
-}
-
-void defaultSetXCutText(char* text, int len, rfbClientPtr cl)
-{
-}
-
-/* TODO: add a nice VNC or RFB cursor */
-
-#if defined(WIN32) || defined(sparc) || defined(_AIX) || defined(__osf__)
-static rfbCursor myCursor =
-{
-   "\000\102\044\030\044\102\000",
-   "\347\347\176\074\176\347\347",
-   8, 7, 3, 3,
-   0, 0, 0,
-   0xffff, 0xffff, 0xffff,
-   0
-};
-#else
-static rfbCursor myCursor =
-{
-   source: "\000\102\044\030\044\102\000",
-   mask:   "\347\347\176\074\176\347\347",
-   width: 8, height: 7, xhot: 3, yhot: 3,
-   /*
-     width: 8, height: 7, xhot: 0, yhot: 0,
-     source: "\000\074\176\146\176\074\000",
-     mask:   "\176\377\377\377\377\377\176",
-   */
-   foreRed: 0, foreGreen: 0, foreBlue: 0,
-   backRed: 0xffff, backGreen: 0xffff, backBlue: 0xffff,
-   richSource: 0
-};
-#endif
-
-rfbCursorPtr defaultGetCursorPtr(rfbClientPtr cl)
-{
-   return(cl->screen->cursor);
-}
-
-/* response is cl->authChallenge vncEncrypted with passwd */
-Bool defaultPasswordCheck(rfbClientPtr cl,const char* response,int len)
-{
-  int i;
-  char *passwd=vncDecryptPasswdFromFile(cl->screen->rfbAuthPasswdData);
-
-  if(!passwd) {
-    rfbLog("Couldn't read password file: %s\n",cl->screen->rfbAuthPasswdData);
-    return(FALSE);
-  }
-
-  vncEncryptBytes(cl->authChallenge, passwd);
-
-  /* Lose the password from memory */
-  for (i = strlen(passwd); i >= 0; i--) {
-    passwd[i] = '\0';
-  }
-
-  free(passwd);
-
-  if (memcmp(cl->authChallenge, response, len) != 0) {
-    rfbLog("rfbAuthProcessClientMessage: authentication failed from %s\n",
-	   cl->host);
-    return(FALSE);
-  }
-
-  return(TRUE);
-}
-
-/* for this method, rfbAuthPasswdData is really a pointer to an array
-   of char*'s, where the last pointer is 0. */
-Bool rfbCheckPasswordByList(rfbClientPtr cl,const char* response,int len)
-{
-  char **passwds;
-
-  for(passwds=(char**)cl->screen->rfbAuthPasswdData;*passwds;passwds++) {
-    vncEncryptBytes(cl->authChallenge, *passwds);
-
-    if (memcmp(cl->authChallenge, response, len) == 0)
-      return(TRUE);
-  }
-
-  rfbLog("rfbAuthProcessClientMessage: authentication failed from %s\n",
-	 cl->host);
-  return(FALSE);
-}
-
-void doNothingWithClient(rfbClientPtr cl)
-{
-}
-
-enum rfbNewClientAction defaultNewClientHook(rfbClientPtr cl)
-{
-	return RFB_CLIENT_ACCEPT;
-}
-
-rfbScreenInfoPtr rfbGetScreen(int* argc,char** argv,
- int width,int height,int bitsPerSample,int samplesPerPixel,
- int bytesPerPixel)
-{
-   rfbScreenInfoPtr rfbScreen=malloc(sizeof(rfbScreenInfo));
-   rfbPixelFormat* format=&rfbScreen->rfbServerFormat;
-
-   INIT_MUTEX(logMutex);
-
-   if(width&3)
-     fprintf(stderr,"WARNING: Width (%d) is not a multiple of 4. VncViewer has problems with that.\n",width);
-
-   rfbScreen->autoPort=FALSE;
-   rfbScreen->rfbClientHead=0;
-   rfbScreen->rfbPort=5900;
-   rfbScreen->socketInitDone=FALSE;
-
-   rfbScreen->inetdInitDone = FALSE;
-   rfbScreen->inetdSock=-1;
-
-   rfbScreen->udpSock=-1;
-   rfbScreen->udpSockConnected=FALSE;
-   rfbScreen->udpPort=0;
-   rfbScreen->udpClient=0;
-
-   rfbScreen->maxFd=0;
-   rfbScreen->rfbListenSock=-1;
-
-   rfbScreen->httpInitDone=FALSE;
-   rfbScreen->httpPort=0;
-   rfbScreen->httpDir=NULL;
-   rfbScreen->httpListenSock=-1;
-   rfbScreen->httpSock=-1;
-   rfbScreen->httpFP=NULL;
-
-   rfbScreen->desktopName = "LibVNCServer";
-   rfbScreen->rfbAlwaysShared = FALSE;
-   rfbScreen->rfbNeverShared = FALSE;
-   rfbScreen->rfbDontDisconnect = FALSE;
-   rfbScreen->rfbAuthPasswdData = 0;
-
-   rfbScreen->width = width;
-   rfbScreen->height = height;
-   rfbScreen->bitsPerPixel = rfbScreen->depth = 8*bytesPerPixel;
-
-   rfbScreen->passwordCheck = defaultPasswordCheck;
-
-   rfbProcessArguments(rfbScreen,argc,argv);
-
-#ifdef WIN32
-   {
-	   DWORD dummy=255;
-	   GetComputerName(rfbScreen->rfbThisHost,&dummy);
-   }
-#else
-   gethostname(rfbScreen->rfbThisHost, 255);
-#endif
-
-   rfbScreen->paddedWidthInBytes = width*bytesPerPixel;
-
-   /* format */
-
-   format->bitsPerPixel = rfbScreen->bitsPerPixel;
-   format->depth = rfbScreen->depth;
-   format->bigEndian = rfbEndianTest?FALSE:TRUE;
-   format->trueColour = TRUE;
-   rfbScreen->colourMap.count = 0;
-   rfbScreen->colourMap.is16 = 0;
-   rfbScreen->colourMap.data.bytes = NULL;
-
-   if(bytesPerPixel == 1) {
-     format->redMax = 7;
-     format->greenMax = 7;
-     format->blueMax = 3;
-     format->redShift = 0;
-     format->greenShift = 3;
-     format->blueShift = 6;
-   } else {
-     format->redMax = (1 << bitsPerSample) - 1;
-     format->greenMax = (1 << bitsPerSample) - 1;
-     format->blueMax = (1 << bitsPerSample) - 1;
-     if(rfbEndianTest) {
-       format->redShift = 0;
-       format->greenShift = bitsPerSample;
-       format->blueShift = bitsPerSample * 2;
-     } else {
-       if(bytesPerPixel==3) {
-	 format->redShift = bitsPerSample*2;
-	 format->greenShift = bitsPerSample*1;
-	 format->blueShift = 0;
-       } else {
-	 format->redShift = bitsPerSample*3;
-	 format->greenShift = bitsPerSample*2;
-	 format->blueShift = bitsPerSample;
-       }
-     }
-   }
-
-   /* cursor */
-
-   rfbScreen->cursorIsDrawn = FALSE;
-   rfbScreen->dontSendFramebufferUpdate = FALSE;
-   rfbScreen->cursorX=rfbScreen->cursorY=rfbScreen->underCursorBufferLen=0;
-   rfbScreen->underCursorBuffer=NULL;
-   rfbScreen->dontConvertRichCursorToXCursor = FALSE;
-   rfbScreen->cursor = &myCursor;
-   INIT_MUTEX(rfbScreen->cursorMutex);
-
-   IF_PTHREADS(rfbScreen->backgroundLoop = FALSE);
-
-   rfbScreen->rfbDeferUpdateTime=5;
-
-   /* proc's and hook's */
-
-   rfbScreen->kbdAddEvent = defaultKbdAddEvent;
-   rfbScreen->kbdReleaseAllKeys = doNothingWithClient;
-   rfbScreen->ptrAddEvent = defaultPtrAddEvent;
-   rfbScreen->setXCutText = defaultSetXCutText;
-   rfbScreen->getCursorPtr = defaultGetCursorPtr;
-   rfbScreen->setTranslateFunction = rfbSetTranslateFunction;
-   rfbScreen->newClientHook = defaultNewClientHook;
-   rfbScreen->displayHook = 0;
-   rfbScreen->inetdDisconnectHook = 0;
-
-   /* initialize client list and iterator mutex */
-   rfbClientListInit(rfbScreen);
-
-   return(rfbScreen);
-}
-
-void rfbScreenCleanup(rfbScreenInfoPtr rfbScreen)
-{
-  rfbClientIteratorPtr i=rfbGetClientIterator(rfbScreen);
-  rfbClientPtr cl,cl1=rfbClientIteratorNext(i);
-  while(cl1) {
-    cl=rfbClientIteratorNext(i);
-    rfbClientConnectionGone(cl1);
-    cl1=cl;
-  }
-  rfbReleaseClientIterator(i);
-
-  /* TODO: hang up on all clients and free all reserved memory */
-#define FREE_IF(x) if(rfbScreen->x) free(rfbScreen->x)
-  FREE_IF(colourMap.data.bytes);
-  FREE_IF(underCursorBuffer);
-  TINI_MUTEX(rfbScreen->cursorMutex);
-  free(rfbScreen);
-}
-
-void rfbInitServer(rfbScreenInfoPtr rfbScreen)
-{
-#ifdef WIN32
-  WSADATA trash;
-  int i=WSAStartup(MAKEWORD(2,2),&trash);
-#endif
-  rfbInitSockets(rfbScreen);
-  httpInitSockets(rfbScreen);
-}
-
-#ifdef WIN32
-#include <fcntl.h>
-#include <conio.h>
-#include <sys/timeb.h>
-
-void gettimeofday(struct timeval* tv,char* dummy)
-{
-   SYSTEMTIME t;
-   GetSystemTime(&t);
-   tv->tv_sec=t.wHour*3600+t.wMinute*60+t.wSecond;
-   tv->tv_usec=t.wMilliseconds*1000;
-}
-#endif
-
-void
-rfbProcessEvents(rfbScreenInfoPtr rfbScreen,long usec)
-{
-  rfbClientIteratorPtr i;
-  rfbClientPtr cl,clPrev;
-  struct timeval tv;
-
-  if(usec<0)
-    usec=rfbScreen->rfbDeferUpdateTime*1000;
-
-  rfbCheckFds(rfbScreen,usec);
-  httpCheckFds(rfbScreen);
-#ifdef CORBA
-  corbaCheckFds(rfbScreen);
-#endif
-
-  i = rfbGetClientIterator(rfbScreen);
-  cl=rfbClientIteratorNext(i);
-  while(cl) {
-    if(cl->sock>=0 && (!cl->onHold) && FB_UPDATE_PENDING(cl)) {
-      if(cl->screen->rfbDeferUpdateTime == 0) {
-	  rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
-      } else if(cl->startDeferring.tv_usec == 0) {
-	gettimeofday(&cl->startDeferring,NULL);
-	if(cl->startDeferring.tv_usec == 0)
-	  cl->startDeferring.tv_usec++;
-      } else {
-	gettimeofday(&tv,NULL);
-	if(tv.tv_sec < cl->startDeferring.tv_sec /* at midnight */
-	   || ((tv.tv_sec-cl->startDeferring.tv_sec)*1000
-	       +(tv.tv_usec-cl->startDeferring.tv_usec)/1000)
-	     > cl->screen->rfbDeferUpdateTime) {
-	  cl->startDeferring.tv_usec = 0;
-	  rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
-	}
-      }
-    }
-    clPrev=cl;
-    cl=rfbClientIteratorNext(i);
-    if(clPrev->sock==-1)
-      rfbClientConnectionGone(clPrev);
-  }
-  rfbReleaseClientIterator(i);
-}
-
-void rfbRunEventLoop(rfbScreenInfoPtr rfbScreen, long usec, Bool runInBackground)
-{
-  if(runInBackground) {
-#ifdef HAVE_PTHREADS
-       pthread_t listener_thread;
-
-       rfbScreen->backgroundLoop = TRUE;
-
-       pthread_create(&listener_thread, NULL, listenerRun, rfbScreen);
-    return;
-#else
-    fprintf(stderr,"Can't run in background, because I don't have PThreads!\n");
-    exit(-1);
-#endif
-  }
-
-  if(usec<0)
-    usec=rfbScreen->rfbDeferUpdateTime*1000;
-
-  while(1)
-    rfbProcessEvents(rfbScreen,usec);
-}
diff --git a/krfb/libvncserver/main.cc b/krfb/libvncserver/main.cc
new file mode 100644
index 00000000..51cfaa5d
--- /dev/null
+++ b/krfb/libvncserver/main.cc
@@ -0,0 +1,784 @@
+/*
+ *  This file is called main.c, because it contains most of the new functions
+ *  for use with LibVNCServer.
+ *
+ *  LibVNCServer (C) 2001 Johannes E. Schindelin <Johannes.Schindelin@gmx.de>
+ *  Original OSXvnc (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
+ *  Original Xvnc (C) 1999 AT&T Laboratories Cambridge.
+ *  All Rights Reserved.
+ *
+ *  see GPL (latest version) for full details
+ */
+
+extern "C" {
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <stdarg.h>
+	#include <errno.h>
+	
+	#ifndef false
+	#define false 0
+	#define true -1
+	#endif
+	
+	#include <sys/types.h>
+	#ifdef __osf__
+	typedef int socklen_t;
+	#endif
+	#ifndef WIN32
+	#include <sys/socket.h>
+	#include <netinet/in.h>
+	#include <unistd.h>
+	#endif
+	#include <signal.h>
+	#include <time.h>
+}
+
+#include <ntqobject.h>
+#include <ntqvariant.h>
+#include <ntqtimer.h>
+#include <ntqthread.h>
+
+extern "C" {
+	#include "rfb.h"
+	#include "sraRegion.h"
+}
+
+#include "main.h"
+
+/* minimum interval between attempts to send something */
+#define PING_MS 10000
+
+MUTEX(logMutex);
+
+int rfbEnableLogging=1;
+
+/* we cannot compare to _LITTLE_ENDIAN, because some systems
+   (as Solaris) assume little endian if _LITTLE_ENDIAN is
+   defined, even if _BYTE_ORDER is not _LITTLE_ENDIAN */
+char rfbEndianTest = (_BYTE_ORDER == 1234);
+
+extern "C" {
+	/* from rfbserver.c */
+	void rfbIncrClientRef(rfbClientPtr cl);
+	void rfbDecrClientRef(rfbClientPtr cl);
+}
+
+ControlPipeHandlerObject* mControlPipeHandler = NULL;
+TQEventLoopThread* mControlPipeHandlerThread = NULL;
+
+OnHoldClientHandlerObject* mOnHoldClientHandler = NULL;
+TQEventLoopThread* mOnHoldClientHandlerThread = NULL;
+
+void rfbLogEnable(int enabled) {
+  rfbEnableLogging=enabled;
+}
+
+/*
+ * rfbLog prints a time-stamped message to the log file (stderr).
+ */
+
+void
+rfbLog(const char *format, ...)
+{
+    va_list args;
+    char buf[256];
+    time_t log_clock;
+
+    if(!rfbEnableLogging)
+      return;
+
+    LOCK(logMutex);
+    va_start(args, format);
+
+    time(&log_clock);
+    strftime(buf, 255, "%d/%m/%Y %T ", localtime(&log_clock));
+    fprintf(stderr, "%s", buf);
+
+    vfprintf(stderr, format, args);
+    fflush(stderr);
+
+    va_end(args);
+    UNLOCK(logMutex);
+}
+
+void rfbLogPerror(const char *str)
+{
+    rfbLog("%s: %s\n", str, strerror(errno));
+}
+
+void rfbScheduleCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy)
+{
+   rfbClientIteratorPtr iterator;
+   rfbClientPtr cl;
+
+   rfbUndrawCursor(rfbScreen);
+
+   iterator=rfbGetClientIterator(rfbScreen);
+   while((cl=rfbClientIteratorNext(iterator))) {
+     LOCK(cl->updateMutex);
+     if(cl->useCopyRect) {
+       sraRegionPtr modifiedRegionBackup;
+       if(!sraRgnEmpty(cl->copyRegion)) {
+	  if(cl->copyDX!=dx || cl->copyDY!=dy) {
+	     /* if a copyRegion was not yet executed, treat it as a
+	      * modifiedRegion. The idea: in this case it could be
+	      * source of the new copyRect or modified anyway. */
+	     sraRgnOr(cl->modifiedRegion,cl->copyRegion);
+	     sraRgnMakeEmpty(cl->copyRegion);
+	  } else {
+	     /* we have to set the intersection of the source of the copy
+	      * and the old copy to modified. */
+	     modifiedRegionBackup=sraRgnCreateRgn(copyRegion);
+	     sraRgnOffset(modifiedRegionBackup,-dx,-dy);
+	     sraRgnAnd(modifiedRegionBackup,cl->copyRegion);
+	     sraRgnOr(cl->modifiedRegion,modifiedRegionBackup);
+	     sraRgnDestroy(modifiedRegionBackup);
+	  }
+       }
+
+       sraRgnOr(cl->copyRegion,copyRegion);
+       cl->copyDX = dx;
+       cl->copyDY = dy;
+
+       /* if there were modified regions, which are now copied,
+	* mark them as modified, because the source of these can be overlapped
+	* either by new modified or now copied regions. */
+       modifiedRegionBackup=sraRgnCreateRgn(cl->modifiedRegion);
+       sraRgnOffset(modifiedRegionBackup,dx,dy);
+       sraRgnAnd(modifiedRegionBackup,cl->copyRegion);
+       sraRgnOr(cl->modifiedRegion,modifiedRegionBackup);
+       sraRgnDestroy(modifiedRegionBackup);
+
+#if 0
+//TODO: is this needed? Or does it mess up deferring?
+       /* while(!sraRgnEmpty(cl->copyRegion)) */ {
+#ifdef HAVE_PTHREADS
+	 if(!cl->screen->backgroundLoop)
+#endif
+	   {
+	     sraRegionPtr updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
+	     sraRgnOr(updateRegion,cl->copyRegion);
+	     UNLOCK(cl->updateMutex);
+	     rfbSendFramebufferUpdate(cl,updateRegion);
+	     sraRgnDestroy(updateRegion);
+	     continue;
+	   }
+       }
+#endif
+     } else {
+       sraRgnOr(cl->modifiedRegion,copyRegion);
+     }
+     TSIGNAL(cl->updateCond);
+     UNLOCK(cl->updateMutex);
+   }
+
+   rfbReleaseClientIterator(iterator);
+}
+
+void rfbDoCopyRegion(rfbScreenInfoPtr rfbScreen,sraRegionPtr copyRegion,int dx,int dy)
+{
+   sraRectangleIterator* i;
+   sraRect rect;
+   int j,widthInBytes,bpp=rfbScreen->rfbServerFormat.bitsPerPixel/8,
+    rowstride=rfbScreen->paddedWidthInBytes;
+   char *in,*out;
+
+   rfbUndrawCursor(rfbScreen);
+
+   /* copy it, really */
+   i = sraRgnGetReverseIterator(copyRegion,dx<0,dy<0);
+   while(sraRgnIteratorNext(i,&rect)) {
+     widthInBytes = (rect.x2-rect.x1)*bpp;
+     out = rfbScreen->frameBuffer+rect.x1*bpp+rect.y1*rowstride;
+     in = rfbScreen->frameBuffer+(rect.x1-dx)*bpp+(rect.y1-dy)*rowstride;
+     if(dy<0)
+       for(j=rect.y1;j<rect.y2;j++,out+=rowstride,in+=rowstride)
+	 memmove(out,in,widthInBytes);
+     else {
+       out += rowstride*(rect.y2-rect.y1-1);
+       in += rowstride*(rect.y2-rect.y1-1);
+       for(j=rect.y2-1;j>=rect.y1;j--,out-=rowstride,in-=rowstride)
+	 memmove(out,in,widthInBytes);
+     }
+   }
+
+   rfbScheduleCopyRegion(rfbScreen,copyRegion,dx,dy);
+}
+
+void rfbDoCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy)
+{
+  sraRegionPtr region = sraRgnCreateRect(x1,y1,x2,y2);
+  rfbDoCopyRegion(rfbScreen,region,dx,dy);
+}
+
+void rfbScheduleCopyRect(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2,int dx,int dy)
+{
+  sraRegionPtr region = sraRgnCreateRect(x1,y1,x2,y2);
+  rfbScheduleCopyRegion(rfbScreen,region,dx,dy);
+}
+
+void rfbMarkRegionAsModified(rfbScreenInfoPtr rfbScreen,sraRegionPtr modRegion)
+{
+   rfbClientIteratorPtr iterator;
+   rfbClientPtr cl;
+
+   iterator=rfbGetClientIterator(rfbScreen);
+   while((cl=rfbClientIteratorNext(iterator))) {
+     LOCK(cl->updateMutex);
+     sraRgnOr(cl->modifiedRegion,modRegion);
+     TSIGNAL(cl->updateCond);
+     UNLOCK(cl->updateMutex);
+   }
+
+   rfbReleaseClientIterator(iterator);
+}
+
+void rfbMarkRectAsModified(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y2)
+{
+   sraRegionPtr region;
+   int i;
+
+   if(x1>x2) { i=x1; x1=x2; x2=i; }
+   if(x1<0) x1=0;
+   if(x2>=rfbScreen->width) x2=rfbScreen->width-1;
+   if(x1==x2) return;
+
+   if(y1>y2) { i=y1; y1=y2; y2=i; }
+   if(y1<0) y1=0;
+   if(y2>=rfbScreen->height) y2=rfbScreen->height-1;
+   if(y1==y2) return;
+
+   region = sraRgnCreateRect(x1,y1,x2,y2);
+   rfbMarkRegionAsModified(rfbScreen,region);
+   sraRgnDestroy(region);
+}
+
+#ifdef HAVE_PTHREADS
+static void *
+clientOutput(void *data)
+{
+    rfbClientPtr cl = (rfbClientPtr)data;
+    Bool haveUpdate;
+    sraRegion* updateRegion;
+
+    while (1) {
+        haveUpdate = false;
+        while (!haveUpdate) {
+            if (cl->sock == -1) {
+                /* Client has disconnected. */
+                return NULL;
+            }
+	    LOCK(cl->updateMutex);
+	    haveUpdate = FB_UPDATE_PENDING(cl);
+	    if(!haveUpdate) {
+		updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
+		haveUpdate = sraRgnAnd(updateRegion,cl->requestedRegion);
+		sraRgnDestroy(updateRegion);
+	    }
+	    UNLOCK(cl->updateMutex);
+
+            if (!haveUpdate) {
+                LOCK(cl->updateMutex);
+                TIMEDWAIT(cl->updateCond, cl->updateMutex, PING_MS);
+		UNLOCK(cl->updateMutex); /* we really needn't lock now. */
+		if (!haveUpdate)
+		    rfbSendPing(cl);
+            }
+        }
+
+        /* OK, now, to save bandwidth, wait a little while for more
+           updates to come along. */
+        usleep(cl->screen->rfbDeferUpdateTime * 1000);
+
+        /* Now, get the region we're going to update, and remove
+           it from cl->modifiedRegion _before_ we send the update.
+           That way, if anything that overlaps the region we're sending
+           is updated, we'll be sure to do another update later. */
+        LOCK(cl->updateMutex);
+	updateRegion = sraRgnCreateRgn(cl->modifiedRegion);
+        UNLOCK(cl->updateMutex);
+
+        /* Now actually send the update. */
+	rfbIncrClientRef(cl);
+        rfbSendFramebufferUpdate(cl, updateRegion);
+	rfbDecrClientRef(cl);
+
+	sraRgnDestroy(updateRegion);
+    }
+
+    return NULL;
+}
+
+static void *
+clientInput(void *data)
+{
+    rfbClientPtr cl = (rfbClientPtr)data;
+    pthread_t output_thread;
+    pthread_create(&output_thread, NULL, clientOutput, (void *)cl);
+
+    while (1) {
+        rfbProcessClientMessage(cl);
+        if (cl->sock == -1) {
+            /* Client has disconnected. */
+            break;
+        }
+    }
+
+    /* Get rid of the output thread. */
+    LOCK(cl->updateMutex);
+    TSIGNAL(cl->updateCond);
+    UNLOCK(cl->updateMutex);
+    IF_PTHREADS(pthread_join(output_thread, NULL));
+
+    rfbClientConnectionGone(cl);
+
+    return NULL;
+}
+
+static void*
+listenerRun(void *data)
+{
+    rfbScreenInfoPtr rfbScreen=(rfbScreenInfoPtr)data;
+    int client_fd;
+    struct sockaddr_in peer;
+    rfbClientPtr cl;
+    size_t len;
+
+    if (rfbScreen->inetdSock != -1) {
+       cl = rfbNewClient(rfbScreen, rfbScreen->inetdSock);
+       if (cl && !cl->onHold)
+           rfbStartOnHoldClient(cl);
+       else if (rfbScreen->inetdDisconnectHook && !cl)
+           rfbScreen->inetdDisconnectHook();
+       return 0;
+    }
+
+    len = sizeof(peer);
+
+    /* TODO: this thread wont die by restarting the server */
+    while ((client_fd = accept(rfbScreen->rfbListenSock,
+                               (struct sockaddr*)&peer, (socklen_t*)(&len))) >= 0) {
+        cl = rfbNewClient(rfbScreen,client_fd);
+        len = sizeof(peer);
+
+	if (cl && !cl->onHold )
+		rfbStartOnHoldClient(cl);
+    }
+    return NULL;
+}
+
+void
+rfbStartOnHoldClient(rfbClientPtr cl)
+{
+	mOnHoldClientHandlerThread = new TQEventLoopThread();
+	mOnHoldClientHandler = new OnHoldClientHandlerObject();
+	mOnHoldClientHandler->d = cl;
+	mOnHoldClientHandler->moveToThread(mOnHoldClientHandlerThread);
+	TQTimer::singleShot(0, mOnHoldClientHandler, SLOT(run()));
+	mOnHoldClientHandlerThread->start();
+}
+
+#else
+
+void
+rfbStartOnHoldClient(rfbClientPtr cl)
+{
+	cl->onHold = FALSE;
+}
+
+#endif
+
+void
+rfbRefuseOnHoldClient(rfbClientPtr cl)
+{
+    rfbCloseClient(cl);
+    rfbClientConnectionGone(cl);
+}
+
+static void
+defaultKbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl)
+{
+}
+
+void
+defaultPtrAddEvent(int buttonMask, int x, int y, rfbClientPtr cl)
+{
+   if(x!=cl->screen->cursorX || y!=cl->screen->cursorY) {
+      cl->cursorWasMoved = TRUE;
+      if(cl->screen->cursorIsDrawn)
+	rfbUndrawCursor(cl->screen);
+      LOCK(cl->screen->cursorMutex);
+      if(!cl->screen->cursorIsDrawn) {
+	  cl->screen->cursorX = x;
+	  cl->screen->cursorY = y;
+      }
+      UNLOCK(cl->screen->cursorMutex);
+   }
+}
+
+void defaultSetXCutText(char* text, int len, rfbClientPtr cl)
+{
+}
+
+/* TODO: add a nice VNC or RFB cursor */
+
+#if defined(WIN32) || defined(sparc) || defined(_AIX) || defined(__osf__)
+static rfbCursor myCursor =
+{
+   "\000\102\044\030\044\102\000",
+   "\347\347\176\074\176\347\347",
+   8, 7, 3, 3,
+   0, 0, 0,
+   0xffff, 0xffff, 0xffff,
+   0
+};
+#else
+static rfbCursor myCursor =
+{
+   source: "\000\102\044\030\044\102\000",
+   mask:   "\347\347\176\074\176\347\347",
+   width: 8, height: 7, xhot: 3, yhot: 3,
+   /*
+     width: 8, height: 7, xhot: 0, yhot: 0,
+     source: "\000\074\176\146\176\074\000",
+     mask:   "\176\377\377\377\377\377\176",
+   */
+   foreRed: 0, foreGreen: 0, foreBlue: 0,
+   backRed: 0xffff, backGreen: 0xffff, backBlue: 0xffff,
+   richSource: 0
+};
+#endif
+
+rfbCursorPtr defaultGetCursorPtr(rfbClientPtr cl)
+{
+   return(cl->screen->cursor);
+}
+
+/* response is cl->authChallenge vncEncrypted with passwd */
+Bool defaultPasswordCheck(rfbClientPtr cl,const char* response,int len)
+{
+  int i;
+  char *passwd = vncDecryptPasswdFromFile((char*)(cl->screen->rfbAuthPasswdData));
+
+  if(!passwd) {
+    rfbLog("Couldn't read password file: %s\n",cl->screen->rfbAuthPasswdData);
+    return(FALSE);
+  }
+
+  vncEncryptBytes(cl->authChallenge, passwd);
+
+  /* Lose the password from memory */
+  for (i = strlen(passwd); i >= 0; i--) {
+    passwd[i] = '\0';
+  }
+
+  free(passwd);
+
+  if (memcmp(cl->authChallenge, response, len) != 0) {
+    rfbLog("rfbAuthProcessClientMessage: authentication failed from %s\n",
+	   cl->host);
+    return(FALSE);
+  }
+
+  return(TRUE);
+}
+
+/* for this method, rfbAuthPasswdData is really a pointer to an array
+   of char*'s, where the last pointer is 0. */
+Bool rfbCheckPasswordByList(rfbClientPtr cl,const char* response,int len)
+{
+  char **passwds;
+
+  for(passwds=(char**)cl->screen->rfbAuthPasswdData;*passwds;passwds++) {
+    vncEncryptBytes(cl->authChallenge, *passwds);
+
+    if (memcmp(cl->authChallenge, response, len) == 0)
+      return(TRUE);
+  }
+
+  rfbLog("rfbAuthProcessClientMessage: authentication failed from %s\n",
+	 cl->host);
+  return(FALSE);
+}
+
+void doNothingWithClient(rfbClientPtr cl)
+{
+}
+
+enum rfbNewClientAction defaultNewClientHook(rfbClientPtr cl)
+{
+	return RFB_CLIENT_ACCEPT;
+}
+
+rfbScreenInfoPtr rfbGetScreen(int* argc,char** argv,
+ int width,int height,int bitsPerSample,int samplesPerPixel,
+ int bytesPerPixel)
+{
+   rfbScreenInfoPtr rfbScreen=(rfbScreenInfoPtr)(malloc(sizeof(rfbScreenInfo)));
+   rfbPixelFormat* format=&rfbScreen->rfbServerFormat;
+
+   INIT_MUTEX(logMutex);
+
+   if(width&3)
+     fprintf(stderr,"WARNING: Width (%d) is not a multiple of 4. VncViewer has problems with that.\n",width);
+
+   rfbScreen->autoPort=FALSE;
+   rfbScreen->rfbClientHead=0;
+   rfbScreen->rfbPort=5900;
+   rfbScreen->socketInitDone=FALSE;
+
+   rfbScreen->inetdInitDone = FALSE;
+   rfbScreen->inetdSock=-1;
+
+   rfbScreen->udpSock=-1;
+   rfbScreen->udpSockConnected=FALSE;
+   rfbScreen->udpPort=0;
+   rfbScreen->udpClient=0;
+
+   rfbScreen->maxFd=0;
+   rfbScreen->rfbListenSock=-1;
+
+   rfbScreen->httpInitDone=FALSE;
+   rfbScreen->httpPort=0;
+   rfbScreen->httpDir=NULL;
+   rfbScreen->httpListenSock=-1;
+   rfbScreen->httpSock=-1;
+   rfbScreen->httpFP=NULL;
+
+   rfbScreen->desktopName = "LibVNCServer";
+   rfbScreen->rfbAlwaysShared = FALSE;
+   rfbScreen->rfbNeverShared = FALSE;
+   rfbScreen->rfbDontDisconnect = FALSE;
+   rfbScreen->rfbAuthPasswdData = 0;
+
+   rfbScreen->width = width;
+   rfbScreen->height = height;
+   rfbScreen->bitsPerPixel = rfbScreen->depth = 8*bytesPerPixel;
+
+   rfbScreen->passwordCheck = defaultPasswordCheck;
+
+   rfbProcessArguments(rfbScreen,argc,argv);
+
+#ifdef WIN32
+   {
+	   DWORD dummy=255;
+	   GetComputerName(rfbScreen->rfbThisHost,&dummy);
+   }
+#else
+   gethostname(rfbScreen->rfbThisHost, 255);
+#endif
+
+   rfbScreen->paddedWidthInBytes = width*bytesPerPixel;
+
+   /* format */
+
+   format->bitsPerPixel = rfbScreen->bitsPerPixel;
+   format->depth = rfbScreen->depth;
+   format->bigEndian = rfbEndianTest?FALSE:TRUE;
+   format->trueColour = TRUE;
+   rfbScreen->colourMap.count = 0;
+   rfbScreen->colourMap.is16 = 0;
+   rfbScreen->colourMap.data.bytes = NULL;
+
+   if(bytesPerPixel == 1) {
+     format->redMax = 7;
+     format->greenMax = 7;
+     format->blueMax = 3;
+     format->redShift = 0;
+     format->greenShift = 3;
+     format->blueShift = 6;
+   } else {
+     format->redMax = (1 << bitsPerSample) - 1;
+     format->greenMax = (1 << bitsPerSample) - 1;
+     format->blueMax = (1 << bitsPerSample) - 1;
+     if(rfbEndianTest) {
+       format->redShift = 0;
+       format->greenShift = bitsPerSample;
+       format->blueShift = bitsPerSample * 2;
+     } else {
+       if(bytesPerPixel==3) {
+	 format->redShift = bitsPerSample*2;
+	 format->greenShift = bitsPerSample*1;
+	 format->blueShift = 0;
+       } else {
+	 format->redShift = bitsPerSample*3;
+	 format->greenShift = bitsPerSample*2;
+	 format->blueShift = bitsPerSample;
+       }
+     }
+   }
+
+   /* cursor */
+
+   rfbScreen->cursorIsDrawn = FALSE;
+   rfbScreen->dontSendFramebufferUpdate = FALSE;
+   rfbScreen->cursorX=rfbScreen->cursorY=rfbScreen->underCursorBufferLen=0;
+   rfbScreen->underCursorBuffer=NULL;
+   rfbScreen->dontConvertRichCursorToXCursor = FALSE;
+   rfbScreen->cursor = &myCursor;
+   INIT_MUTEX(rfbScreen->cursorMutex);
+
+   IF_PTHREADS(rfbScreen->backgroundLoop = FALSE);
+
+   rfbScreen->rfbDeferUpdateTime=5;
+
+   /* proc's and hook's */
+
+   rfbScreen->kbdAddEvent = defaultKbdAddEvent;
+   rfbScreen->kbdReleaseAllKeys = doNothingWithClient;
+   rfbScreen->ptrAddEvent = defaultPtrAddEvent;
+   rfbScreen->setXCutText = defaultSetXCutText;
+   rfbScreen->getCursorPtr = defaultGetCursorPtr;
+   rfbScreen->setTranslateFunction = rfbSetTranslateFunction;
+   rfbScreen->newClientHook = defaultNewClientHook;
+   rfbScreen->displayHook = 0;
+   rfbScreen->inetdDisconnectHook = 0;
+
+   /* initialize client list and iterator mutex */
+   rfbClientListInit(rfbScreen);
+
+   return(rfbScreen);
+}
+
+void rfbScreenCleanup(rfbScreenInfoPtr rfbScreen)
+{
+  rfbClientIteratorPtr i=rfbGetClientIterator(rfbScreen);
+  rfbClientPtr cl,cl1=rfbClientIteratorNext(i);
+  while(cl1) {
+    cl=rfbClientIteratorNext(i);
+    rfbClientConnectionGone(cl1);
+    cl1=cl;
+  }
+  rfbReleaseClientIterator(i);
+
+  /* TODO: hang up on all clients and free all reserved memory */
+#define FREE_IF(x) if(rfbScreen->x) free(rfbScreen->x)
+  FREE_IF(colourMap.data.bytes);
+  FREE_IF(underCursorBuffer);
+  TINI_MUTEX(rfbScreen->cursorMutex);
+  free(rfbScreen);
+}
+
+void rfbInitServer(rfbScreenInfoPtr rfbScreen)
+{
+#ifdef WIN32
+  WSADATA trash;
+  int i=WSAStartup(MAKEWORD(2,2),&trash);
+#endif
+  rfbInitSockets(rfbScreen);
+  httpInitSockets(rfbScreen);
+}
+
+#ifdef WIN32
+#include <fcntl.h>
+#include <conio.h>
+#include <sys/timeb.h>
+
+void gettimeofday(struct timeval* tv,char* dummy)
+{
+   SYSTEMTIME t;
+   GetSystemTime(&t);
+   tv->tv_sec=t.wHour*3600+t.wMinute*60+t.wSecond;
+   tv->tv_usec=t.wMilliseconds*1000;
+}
+#endif
+
+void
+rfbProcessEvents(rfbScreenInfoPtr rfbScreen,long usec)
+{
+  rfbClientIteratorPtr i;
+  rfbClientPtr cl,clPrev;
+  struct timeval tv;
+
+  if(usec<0)
+    usec=rfbScreen->rfbDeferUpdateTime*1000;
+
+  rfbCheckFds(rfbScreen,usec);
+  httpCheckFds(rfbScreen);
+#ifdef CORBA
+  corbaCheckFds(rfbScreen);
+#endif
+
+  i = rfbGetClientIterator(rfbScreen);
+  cl=rfbClientIteratorNext(i);
+  while(cl) {
+    if(cl->sock>=0 && (!cl->onHold) && FB_UPDATE_PENDING(cl)) {
+      if(cl->screen->rfbDeferUpdateTime == 0) {
+	  rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
+      } else if(cl->startDeferring.tv_usec == 0) {
+	gettimeofday(&cl->startDeferring,NULL);
+	if(cl->startDeferring.tv_usec == 0)
+	  cl->startDeferring.tv_usec++;
+      } else {
+	gettimeofday(&tv,NULL);
+	if(tv.tv_sec < cl->startDeferring.tv_sec /* at midnight */
+	   || ((tv.tv_sec-cl->startDeferring.tv_sec)*1000
+	       +(tv.tv_usec-cl->startDeferring.tv_usec)/1000)
+	     > cl->screen->rfbDeferUpdateTime) {
+	  cl->startDeferring.tv_usec = 0;
+	  rfbSendFramebufferUpdate(cl,cl->modifiedRegion);
+	}
+      }
+    }
+    clPrev=cl;
+    cl=rfbClientIteratorNext(i);
+    if(clPrev->sock==-1)
+      rfbClientConnectionGone(clPrev);
+  }
+  rfbReleaseClientIterator(i);
+}
+
+void rfbRunEventLoop(rfbScreenInfoPtr rfbScreen, long usec, Bool runInBackground)
+{
+	if (runInBackground) {
+#ifdef HAVE_PTHREADS
+		rfbScreen->backgroundLoop = TRUE;
+	
+		mControlPipeHandlerThread = new TQEventLoopThread();
+		mControlPipeHandler = new ControlPipeHandlerObject();
+		mControlPipeHandler->d = rfbScreen;
+		mControlPipeHandler->moveToThread(mControlPipeHandlerThread);
+		TQTimer::singleShot(0, mControlPipeHandler, SLOT(run()));
+		mControlPipeHandlerThread->start();
+		return;
+#else
+		fprintf(stderr,"Can't run in background, because I don't have PThreads!\n");
+		exit(-1);
+#endif
+	}
+
+	if (usec<0) {
+		usec=rfbScreen->rfbDeferUpdateTime*1000;
+	}
+
+	while (1) {
+		rfbProcessEvents(rfbScreen,usec);
+	}
+}
+
+ControlPipeHandlerObject::ControlPipeHandlerObject() : TQObject() {
+	//
+}
+
+ControlPipeHandlerObject::~ControlPipeHandlerObject() {
+	//
+}
+
+void ControlPipeHandlerObject::run(void) {
+	listenerRun(d);
+}
+
+OnHoldClientHandlerObject::OnHoldClientHandlerObject() : TQObject() {
+	//
+}
+
+OnHoldClientHandlerObject::~OnHoldClientHandlerObject() {
+	//
+}
+
+void OnHoldClientHandlerObject::run(void) {
+	clientInput(d);
+}
+
+#include "main.moc"
\ No newline at end of file
diff --git a/krfb/libvncserver/main.h b/krfb/libvncserver/main.h
new file mode 100644
index 00000000..f662a212
--- /dev/null
+++ b/krfb/libvncserver/main.h
@@ -0,0 +1,43 @@
+/*
+ *  LibVNCServer (C) 2001 Johannes E. Schindelin <Johannes.Schindelin@gmx.de>
+ *  Original OSXvnc (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
+ *  Original Xvnc (C) 1999 AT&T Laboratories Cambridge.
+ *  All Rights Reserved.
+ *
+ *  see GPL (latest version) for full details
+ */
+
+#ifndef _MAIN_H
+#define _MAIN_H
+
+class ControlPipeHandlerObject : public TQObject
+{
+	Q_OBJECT
+
+	public:
+		ControlPipeHandlerObject();
+		~ControlPipeHandlerObject();
+
+	public slots:
+		void run();
+
+	public:
+		rfbScreenInfoPtr d;
+};
+
+class OnHoldClientHandlerObject : public TQObject
+{
+	Q_OBJECT
+
+	public:
+		OnHoldClientHandlerObject();
+		~OnHoldClientHandlerObject();
+
+	public slots:
+		void run();
+
+	public:
+		rfbClientPtr d;
+};
+
+#endif // _MAIN_H
\ No newline at end of file
diff --git a/krfb/libvncserver/rfb.h b/krfb/libvncserver/rfb.h
index e8dbfb65..55736af8 100644
--- a/krfb/libvncserver/rfb.h
+++ b/krfb/libvncserver/rfb.h
@@ -154,7 +154,7 @@ typedef unsigned long KeySym;
 #define TIMEDWAIT(cond,mutex,t) {struct timeval tv;\
   tv.tv_sec = (t) / 1000;\
   tv.tv_usec = ((t) % 1000) * 1000;\
-  pthread_cond_timedwait(&(cond),&(mutex),&tv);}
+  pthread_cond_timedwait(&(cond),&(mutex),(const timespec*)(&tv));}
 #define COND(cond) pthread_cond_t (cond)
 #define INIT_COND(cond) pthread_cond_init(&(cond),NULL)
 #define TINI_COND(cond) pthread_cond_destroy(&(cond))
@@ -725,12 +725,12 @@ extern Bool rfbSendRectEncodingTight(rfbClientPtr cl, int x,int y,int w,int h);
 /* cursor.c */
 
 typedef struct rfbCursor {
-    unsigned char *source;			/* points to bits */
-    unsigned char *mask;			/* points to bits */
-    unsigned short width, height, xhot, yhot;	/* metrics */
-    unsigned short foreRed, foreGreen, foreBlue; /* device-independent colour */
-    unsigned short backRed, backGreen, backBlue; /* device-independent colour */
-    unsigned char *richSource; /* source bytes for a rich cursor */
+    const char *source;					/* points to bits */
+    const char *mask;					/* points to bits */
+    unsigned short width, height, xhot, yhot;		/* metrics */
+    unsigned short foreRed, foreGreen, foreBlue;	/* device-independent colour */
+    unsigned short backRed, backGreen, backBlue;	/* device-independent colour */
+    unsigned char *richSource;				/* source bytes for a rich cursor */
 } rfbCursor, *rfbCursorPtr;
 
 extern Bool rfbSendCursorShape(rfbClientPtr cl/*, rfbScreenInfoPtr pScreen*/);
-- 
cgit v1.2.3

