AC_ARG_ENABLE(xcliplist,      AS_HELP_STRING([--enable-xcliplist], [Build XClipList extension (default: auto)]), [XCLIPLIST=$enableval], [XCLIPLIST=auto])

AC_ARG_ENABLE(vnc,    	      AS_HELP_STRING([--enable-vnc], [Build Xvnc server (default: yes)]), [VNC=$enableval], [VNC=auto])

if test "x$XCLIPLIST" = xauto; then

	if test "x$XORG" = xno; then

		XCLIPLIST=no

	else

		PKG_CHECK_MODULES([XCLIPLIST], [xcliplistproto xcliplist], [XCLIPLIST=yes], [XCLIPLIST=no])

	fi

fi

AM_CONDITIONAL(XCLIPLIST, [test "x$XCLIPLIST" = xyes])

if test "x$XCLIPLIST" = xyes; then

	AC_DEFINE(XCLIPLIST, 1, [Support XClipList extension])

	REQUIRED_MODULES="$REQUIRED_MODULES xcliplistproto"

	XCLIPLIST_LIB='$(top_builddir)/xcliplist/libxcliplist.la'

fi

MFB_LIB='$(top_builddir)/mfb/libmfb.la'

MFB_INC='-I$(top_srcdir)/mfb'

dnl VNC DDX

AC_MSG_CHECKING([whether to build Xvnc DDX])

PKG_CHECK_MODULES([VNCMODULES], [xmuu xext x11 xrender xfont xi vncproto xau $XDMCP_MODULES $PIXMAN], [have_vnc=yes], [have_vnc=no])

if test "x$VNC" = xauto; then

	VNC="$have_vnc"

fi

AC_MSG_RESULT([$VNC])

AM_CONDITIONAL(VNC, [test "x$VNC" = xyes])

if test "x$VNC" = xyes; then

	if test "x$have_vnc" = xno; then

		AC_MSG_ERROR([Xvnc build explicitly requested, but required

		              modules not found.])

	fi

	XVNC_CFLAGS="-DVNCSERVER -DHAVE_XVNC_CONFIG_H $PIXMAN_CFLAGS"

	AC_SUBST([XVNC_CFLAGS])

	VNC_INCLUDES="$XEXT_INC $RENDER_INC $XTRAP_INC $RECORD_INC"

	XVNC_LIBS="$GLX_LIBS $MFB_LIB $FB_LIB $MI_LIB $XEXT_LIB $RENDER_LIB $XTRAP_LIB $RECORD_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $OS_LIB $CWRAP_LIB"

	AC_SUBST([XVNC_LIBS])

	if test "x$GLX" = xyes; then

		PKG_CHECK_MODULES([GL], [glproto])

	fi

	PKG_CHECK_MODULES([XVNCCONFIG_DEP], [xaw7 xmu xt xpm x11])

	AC_SUBST(XVNCCONFIG_DEP_CFLAGS)

	AC_SUBST(XVNCCONFIG_DEP_LIBS)

        $srcdir/hw/vnc/symlink-vnc.sh $srcdir/hw/vnc $srcdir/hw/xfree86/vnc

        $srcdir/hw/vnc/symlink-vnc.sh $srcdir/hw/vnc $srcdir/hw/dmx/vnc

fi

xcliplist/Makefile

hw/xfree86/vnc/Makefile

hw/dmx/vnc/Makefile

hw/vnc/Makefile

/* Enable VNC ability */

#define DMXVNC 1

#ifdef DMXVNC

extern void VNCInitForDMX(void);

#endif

#ifdef DMXVNC

    VNCInitForDMX();

#endif

#ifdef DDXTIME

/** Return wall-clock time in milliseconds. */

CARD32 GetTimeInMillis(void)

{

    struct timeval  tp;

    gettimeofday(&tp, 0);

    return tp.tv_sec * 1000 + tp.tv_usec / 1000;

}

#endif

#ifdef DMXVNC

extern void rfbWakeupHandlerDMX(void);

#endif

#ifdef DMXVNC

   rfbWakeupHandlerDMX();

#endif

#ifdef DMXVNC

    vncSetKeyboardDevice(pDevice);

#endif

#ifdef DMXVNC

            vncSetKeyboardDevice(pDevice);

#endif

#ifdef DMXVNC

            vncSetPointerDevice(pDevice);

#endif

#ifdef DMXVNC

extern void vncSetKeyboardDevice(DeviceIntPtr kbd);

extern void vncSetPointerDevice(DeviceIntPtr ptr);

#endif

            -DDMXVNC=1 \

             vnc/libdmxvnc.a \

             -ljpeg -lcrypt \

noinst_LIBRARIES = libdmxvnc.a

SRCS = \

	auth.c \

	cmap.c \

	corre.c \

	cursor.c \

	cutpaste.c \

	d3des.c \

	dispcur.c \

	draw.c \

	hextile.c \

	httpd.c \

	kbdptr.c \

	loginauth.c \

	rdp.c \

	rfbkeyb.c \

	rfbmouse.c \

	rfbserver.c \

	rre.c \

	sockets.c \

	sprite.c \

	stats.c \

	tight.c \

	translate.c \

	vncauth.c \

	vncext.c \

	vncInit.c \

	xistubs.c \

	zlib.c

libdmxvnc_a_SOURCES = $(SRCS)

AM_CFLAGS = \

            -I$(top_srcdir)/hw/dmx \

            -I$(top_srcdir)/hw/xfree86/common \

            -DHAVE_DMX_CONFIG_H \

	    $(DIX_CFLAGS) \

            -DDMXVNC=1 \

            @DMXMODULES_CFLAGS@

###EXTRA_DIST = dmxdetach.c

/*

 *  Copyright (C) 2002 Alan Hourihane.  All Rights Reserved.

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 *

 *  Author: Alan Hourihane <alanh@fairlite.demon.co.uk>

 */

#include "rfb.h"

#ifdef HAVE_DMX_CONFIG_H

#include "dmx-config.h"

#endif

#ifdef DMXVNC

#include "../dmx.h"

#include "../dmxcb.h"

#endif

#include <time.h>

#include "fb.h"

#include "dixstruct.h"

#include "compiler.h"

#include "mipointer.h"

#include "mibstore.h"

#include "globals.h"

#define DPMS_SERVER

#include <X11/extensions/dpms.h>

#include <netinet/in.h>

int vncScreenPrivateIndex = -1;

int rfbGCIndex = -1;

int inetdSock = -1;

Atom VNC_LAST_CLIENT_ID = 0;

Atom VNC_CONNECT = 0;

char *desktopName = "x11";

char rfbThisHost[256];

extern void VncExtensionInit(void);

extern void vncInitMouse(void);

extern void vncInitKeyb(void);

Bool VNCInit(ScreenPtr pScreen, DMXScreenInfo *dmxScreen);

#ifndef XFree86LOADER

static unsigned long VNCGeneration = 0;

#endif

static void rfbWakeupHandler (int i, pointer blockData, unsigned long err, pointer pReadmask);

/*

 * rfbLog prints a time-stamped message to the log file (stderr).

 */

void rfbLog(char *format, ...)

{

    va_list args;

    char buf[256];

    time_t clock;

    va_start(args, format);

    time(&clock);

    strftime(buf, 255, "%d/%m/%Y %H:%M:%S ", localtime(&clock));

    fprintf(stderr, buf);

    vfprintf(stderr, format, args);

    fflush(stderr);

    va_end(args);

}

void rfbLogPerror(char *str)

{

    rfbLog("");

    perror(str);

}

static ScreenPtr TheVNCScreen = NULL;

static void

nopGetImage(DrawablePtr pDrawable, int sx, int sy,

            int w, int h, unsigned int format,

            unsigned long planemask, char *pdstLine)

{

   ScreenPtr pScreen = pDrawable->pScreen;

   (*pScreen->GetImage)(pDrawable,sx,sy,w,h,format,planemask,pdstLine);

}

static void

SetupVNCScreen(void)

{

    vncScreenPtr pScreenPriv;

    VisualPtr v = NULL;

    int i;

    pScreenPriv = xalloc(sizeof(vncScreenRec));

    pScreenPriv->width = dmxGlobalWidth;

    pScreenPriv->height = dmxGlobalHeight;

    pScreenPriv->rfbAuthTries = 0;

    pScreenPriv->rfbAuthTooManyTries = FALSE;

    pScreenPriv->timer = NULL;

    pScreenPriv->udpPort = 0;

    pScreenPriv->rfbListenSock = -1;

    pScreenPriv->udpSock = -1;

    pScreenPriv->udpSockConnected = FALSE;

    pScreenPriv->httpListenSock = -1;

    pScreenPriv->httpSock = -1;

    pScreenPriv->maxFd = 0;

    pScreenPriv->rfbAuthPasswdFile = NULL;

    pScreenPriv->httpDir = NULL;

    pScreenPriv->rfbInstalledColormap = NULL;

    pScreenPriv->interface.s_addr = htonl (INADDR_ANY);

    pScreenPriv->rfbPort = 0;

    pScreenPriv->httpPort = 0;

    pScreenPriv->rfbAuthPasswdFile = NULL;

    pScreenPriv->httpDir = NULL;

    pScreenPriv->rfbAlwaysShared = FALSE;

    pScreenPriv->rfbNeverShared = FALSE;

    pScreenPriv->rfbUserAccept = FALSE;

    pScreenPriv->rfbViewOnly = FALSE;

    pScreenPriv->rfbDontDisconnect = FALSE;

    pScreenPriv->loginAuthEnabled = FALSE;

    /* Find the root window's visual.

     * XXX this might be the wrong info to use below.

     */

    for (i = 0; i < screenInfo.screens[0]->numVisuals; i++) {

        v = screenInfo.screens[0]->visuals + i;

        if (v->vid == screenInfo.screens[0]->rootVisual) {

            break;

        }

    }

    /* XXX is this the right depth and bpp? */

    /* With DMX, screenInfo.screens[0]->rootDepth is 24 and that doesn't

     * work in translate.c!  We're just using 32.

     */

    pScreenPriv->rfbServerFormat.bitsPerPixel = 32;

    pScreenPriv->rfbServerFormat.depth = 32;

    pScreenPriv->rfbServerFormat.bigEndian = 0;

    pScreenPriv->rfbServerFormat.trueColour = (v->class == TrueColor);

    if (pScreenPriv->rfbServerFormat.trueColour) {

	pScreenPriv->rfbServerFormat.redMax = v->redMask >> v->offsetRed;

	pScreenPriv->rfbServerFormat.greenMax = v->greenMask >> v->offsetGreen;

	pScreenPriv->rfbServerFormat.blueMax = v->blueMask >> v->offsetBlue;

	pScreenPriv->rfbServerFormat.redShift = v->offsetRed;

	pScreenPriv->rfbServerFormat.greenShift = v->offsetGreen;

	pScreenPriv->rfbServerFormat.blueShift = v->offsetBlue;

    } else {

	pScreenPriv->rfbServerFormat.redMax

	    = pScreenPriv->rfbServerFormat.greenMax 

	    = pScreenPriv->rfbServerFormat.blueMax = 0;

	pScreenPriv->rfbServerFormat.redShift

	    = pScreenPriv->rfbServerFormat.greenShift 

	    = pScreenPriv->rfbServerFormat.blueShift = 0;

    }

    /* Allocate/init TheVNCScreen object */

    vncScreenPrivateIndex = 0;

    TheVNCScreen = (ScreenPtr) Xcalloc(1, sizeof(struct _Screen));

    TheVNCScreen->devPrivates = (DevUnion *) Xcalloc(1, sizeof(DevUnion));

    TheVNCScreen->devPrivates[vncScreenPrivateIndex].ptr = pScreenPriv;

    TheVNCScreen->GetImage = nopGetImage;

    rfbInitSockets(TheVNCScreen);

    if (inetdSock == -1)

       httpInitSockets(TheVNCScreen);

}

/*

 * Called by DMX's InitOutput()

 * Will be called for each X server generation.

 */

void

VNCInitForDMX(void)

{

    rfbLog("DMXVNC: Initializing VNC for DMX\n");

    ErrorF("DMXVNC: Initializing VNC for DMX\n");

    if (TheVNCScreen) {

        rfbLog("DMXVNC: New server generation\n");

    }

    else {

        rfbLog("DMXVNC: Set up VNC screen\n");

        SetupVNCScreen();

    }

    /* Reset the input device pointers.  They'll get set later.

     * This allows successful server regeneration.

    */

    vncSetKeyboardDevice(NULL);

    vncSetPointerDevice(NULL);

}

Bool

VNCInit(ScreenPtr pScreen, DMXScreenInfo *pScrn)

{

    VisualPtr visual;

    vncScreenPtr pScreenPriv;

#if 0

    char *interface_str = NULL;

#endif

#ifdef RENDER

    PictureScreenPtr	ps;

#endif

#ifndef XFree86LOADER

    if (VNCGeneration != serverGeneration) {

	VNCGeneration = serverGeneration;

	if ( ((vncScreenPrivateIndex = AllocateScreenPrivateIndex()) < 0) ||

	    ((rfbGCIndex = AllocateGCPrivateIndex()) < 0) )

		return FALSE;

    }

#endif

    if (!AllocateGCPrivate(pScreen, rfbGCIndex, sizeof(rfbGCRec))) {

	ErrorF("VNCInit(): failed to allocate GCIndex\n");

	return FALSE;

    }

    if (!(pScreenPriv = xalloc(sizeof(vncScreenRec))))

	return FALSE;

    pScreen->devPrivates[vncScreenPrivateIndex].ptr = (pointer)pScreenPriv;

    pScreenPriv->rfbAuthTries = 0;

    pScreenPriv->rfbAuthTooManyTries = FALSE;

    pScreenPriv->timer = NULL;

    pScreenPriv->udpPort = 0;

    pScreenPriv->rfbListenSock = -1;

    pScreenPriv->udpSock = -1;

    pScreenPriv->udpSockConnected = FALSE;

    pScreenPriv->httpListenSock = -1;

    pScreenPriv->httpSock = -1;

    pScreenPriv->maxFd = 0;

    pScreenPriv->rfbAuthPasswdFile = NULL;

    pScreenPriv->httpDir = NULL;

    pScreenPriv->rfbInstalledColormap = NULL;

    pScreenPriv->interface.s_addr = htonl (INADDR_ANY);

    pScreenPriv->rfbPort = 0;

    pScreenPriv->httpPort = 0;

    pScreenPriv->rfbAuthPasswdFile = NULL;

    pScreenPriv->httpDir = NULL;

    pScreenPriv->rfbAlwaysShared = FALSE;

    pScreenPriv->rfbNeverShared = FALSE;

    pScreenPriv->rfbUserAccept = FALSE;

    pScreenPriv->rfbViewOnly = FALSE;

    pScreenPriv->rfbDontDisconnect = FALSE;

    pScreenPriv->loginAuthEnabled = FALSE;

#if 0

    if (xf86ReturnOptValBool(options, OPTION_LOCALHOST, FALSE))

	pScreenPriv->interface.s_addr = htonl (INADDR_LOOPBACK);

    interface_str = xf86GetOptValString(options, OPTION_INTERFACE);

    if (interface_str && pScreenPriv->interface.s_addr == htonl(INADDR_ANY)) {

	Bool failed = FALSE;

	struct in_addr got;

	unsigned long octet;

	char *p = interface_str, *end;

	int q;

	for (q = 0; q < 4; q++) {

	    octet = strtoul (p, &end, 10);

	    if (p == end || octet > 255)

		failed = TRUE;

	    if ((q < 3 && *end != '.') ||

	        (q == 3 && *end != '\0'))

		failed = TRUE;

	    got.s_addr = (got.s_addr << 8) | octet;

	    p = end + 1;

	}

	if (!failed)

	    pScreenPriv->interface.s_addr = htonl (got.s_addr);

	else

	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VNC interface option malformed, not using.\n");

    }

#endif

    if (!VNC_LAST_CLIENT_ID)

    	VNC_LAST_CLIENT_ID = MakeAtom("VNC_LAST_CLIENT_ID",

				  strlen("VNC_LAST_CLIENT_ID"), TRUE);

    if (!VNC_CONNECT)

    	VNC_CONNECT = MakeAtom("VNC_CONNECT", strlen("VNC_CONNECT"), TRUE);

    rfbInitSockets(pScreen);

    if (inetdSock == -1)

    	httpInitSockets(pScreen);

#ifdef CORBA

    initialiseCORBA(argc, argv, desktopName);

#endif

    pScreenPriv->width = pScrn->scrnWidth;

    pScreenPriv->height = pScrn->scrnHeight;

    pScreenPriv->depth = pScrn->beDepth;

    pScreenPriv->paddedWidthInBytes = PixmapBytePad(pScrn->scrnWidth, pScrn->beDepth);

    pScreenPriv->bitsPerPixel = rfbBitsPerPixel(pScrn->beDepth);

    pScreenPriv->pfbMemory = NULL;

    pScreenPriv->oldpfbMemory = NULL;

    pScreenPriv->cursorIsDrawn = TRUE;

    pScreenPriv->dontSendFramebufferUpdate = FALSE;

    pScreenPriv->CloseScreen = pScreen->CloseScreen;

    pScreenPriv->CreateGC = pScreen->CreateGC;

    pScreenPriv->PaintWindowBackground = pScreen->PaintWindowBackground;

    pScreenPriv->PaintWindowBorder = pScreen->PaintWindowBorder;

    pScreenPriv->CopyWindow = pScreen->CopyWindow;

    pScreenPriv->ClearToBackground = pScreen->ClearToBackground;

    pScreenPriv->RestoreAreas = pScreen->RestoreAreas;

    pScreenPriv->WakeupHandler = pScreen->WakeupHandler;

    pScreenPriv->InstallColormap = pScreen->InstallColormap;

    pScreenPriv->UninstallColormap = pScreen->UninstallColormap;

    pScreenPriv->ListInstalledColormaps = pScreen->ListInstalledColormaps;

    pScreenPriv->StoreColors = pScreen->StoreColors;

#ifdef CHROMIUM

    pScreenPriv->RealizeWindow = pScreen->RealizeWindow;

    pScreenPriv->UnrealizeWindow = pScreen->UnrealizeWindow;

    pScreenPriv->DestroyWindow = pScreen->DestroyWindow;

    pScreenPriv->PositionWindow = pScreen->PositionWindow;

    pScreenPriv->ResizeWindow = pScreen->ResizeWindow;

    pScreenPriv->ClipNotify = pScreen->ClipNotify;

#endif

#ifdef RENDER

    ps = GetPictureScreenIfSet(pScreen);

    if (ps)

    	pScreenPriv->Composite = ps->Composite;

#endif

    pScreen->CloseScreen = rfbCloseScreen;

    pScreen->CreateGC = rfbCreateGC;

    pScreen->PaintWindowBackground = rfbPaintWindowBackground;

    pScreen->PaintWindowBorder = rfbPaintWindowBorder;

    pScreen->CopyWindow = rfbCopyWindow;

    pScreen->ClearToBackground = rfbClearToBackground;

    pScreen->RestoreAreas = rfbRestoreAreas;

    pScreen->WakeupHandler = rfbWakeupHandler;

    pScreen->InstallColormap = rfbInstallColormap;

    pScreen->UninstallColormap = rfbUninstallColormap;

    pScreen->ListInstalledColormaps = rfbListInstalledColormaps;

    pScreen->StoreColors = rfbStoreColors;

#ifdef CHROMIUM

    pScreen->RealizeWindow = rfbRealizeWindow;

    pScreen->UnrealizeWindow = rfbUnrealizeWindow;

    pScreen->DestroyWindow = rfbDestroyWindow;

    pScreen->PositionWindow = rfbPositionWindow;

    pScreen->ResizeWindow = rfbResizeWindow;

    pScreen->ClipNotify = rfbClipNotify;

#endif

#ifdef RENDER

    if (ps)

    	ps->Composite = rfbComposite;

#endif

    for (visual = pScreen->visuals; visual->vid != pScreen->rootVisual; visual++)

	;

    if (!visual) {

	ErrorF("rfbScreenInit: couldn't find root visual\n");

	return FALSE;

    }

    pScreenPriv->rfbServerFormat.bitsPerPixel = pScrn->beBPP;

    pScreenPriv->rfbServerFormat.depth = pScrn->beDepth;

    pScreenPriv->rfbServerFormat.bigEndian = !(*(char *)&rfbEndianTest);

    pScreenPriv->rfbServerFormat.trueColour = (visual->class == TrueColor);

    if (pScreenPriv->rfbServerFormat.trueColour) {

	pScreenPriv->rfbServerFormat.redMax = visual->redMask >> visual->offsetRed;

	pScreenPriv->rfbServerFormat.greenMax = visual->greenMask >> visual->offsetGreen;

	pScreenPriv->rfbServerFormat.blueMax = visual->blueMask >> visual->offsetBlue;

	pScreenPriv->rfbServerFormat.redShift = visual->offsetRed;

	pScreenPriv->rfbServerFormat.greenShift = visual->offsetGreen;

	pScreenPriv->rfbServerFormat.blueShift = visual->offsetBlue;

    } else {

	pScreenPriv->rfbServerFormat.redMax

	    = pScreenPriv->rfbServerFormat.greenMax 

	    = pScreenPriv->rfbServerFormat.blueMax = 0;

	pScreenPriv->rfbServerFormat.redShift

	    = pScreenPriv->rfbServerFormat.greenShift 

	    = pScreenPriv->rfbServerFormat.blueShift = 0;

    }

    return TRUE;

}

static void

rfbWakeupHandler (

    int 	i,	

    pointer     blockData,

    unsigned long err,

    pointer     pReadmask

){

    ScreenPtr      pScreen = screenInfo.screens[i];

    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);

    /*DMXScreenInfo *pScrn = &dmxScreens[pScreen->myNum];*/

    rfbRootPropertyChange(pScreen); /* Check clipboard */

    rfbCheckFds(pScreen);

    httpCheckFds(pScreen);

#ifdef CORBA

    corbaCheckFds();

#endif

    pScreen->WakeupHandler = pScreenPriv->WakeupHandler;

    (*pScreen->WakeupHandler) (i, blockData, err, pReadmask);

    pScreen->WakeupHandler = rfbWakeupHandler;

}

/**

 * The rfb wake-up handler used when we're compiled into the DMX server.

 */

void

rfbWakeupHandlerDMX(void)

{

    ScreenPtr      pScreen = TheVNCScreen;

    rfbRootPropertyChange(pScreen); /* Check clipboard */

    rfbCheckFds(pScreen);

    httpCheckFds(pScreen);

}

/*

 *  Copyright (C) 2002 Alan Hourihane.  All Rights Reserved.

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 *

 *  Author: Alan Hourihane <alanh@fairlite.demon.co.uk>

 */

#ifndef _VNCINT_H_

#define _VNCINT_H_

#include <netinet/in.h>

extern int vncScreenPrivateIndex;

#define VNCPTR(pScreen)\

   (vncScreenPtr)((pScreen)->devPrivates[vncScreenPrivateIndex].ptr)

typedef struct {

    int			rfbPort;

    int			rdpPort;

    int			udpPort;

    int			rfbListenSock;

    int			rdpListenSock;

    int			udpSock;

    int			httpPort;

    int			httpListenSock;

    int			httpSock;

    char *		httpDir;

    char		buf[HTTP_BUF_SIZE];

    Bool		udpSockConnected;

    char *		rfbAuthPasswdFile;

    size_t		buf_filled;

    int			maxFd;

    fd_set		allFds;

    unsigned char *	oldpfbMemory;

    Bool		rfbAlwaysShared;

    Bool		rfbNeverShared;

    Bool		rfbDontDisconnect;

    Bool		rfbUserAccept;

    Bool		rfbViewOnly;

    unsigned char *	pfbMemory;

    int 		paddedWidthInBytes;

    ColormapPtr 	rfbInstalledColormap;

    ColormapPtr		savedColormap;

    rfbPixelFormat	rfbServerFormat;

    Bool		rfbAuthTooManyTries;

    int			rfbAuthTries;

    Bool		loginAuthEnabled;

    struct in_addr	interface;

    OsTimerPtr 		timer;

    unsigned char 	updateBuf[UPDATE_BUF_SIZE];

    int 		ublen;

    int 		width;

    int 		height;

    int 		depth;

    int 		bitsPerPixel;

    /* The following two members are used to minimise the amount of unnecessary

       drawing caused by cursor movement.  Whenever any drawing affects the

       part of the screen where the cursor is, the cursor is removed first and

       then the drawing is done (this is what the sprite routines test for).

       Afterwards, however, we do not replace the cursor, even when the cursor

       is logically being moved across the screen.  We only draw the cursor

       again just as we are about to send the client a framebuffer update.

       We need to be careful when removing and drawing the cursor because of

       their relationship with the normal drawing routines.  The drawing

       routines can invoke the cursor routines, but also the cursor routines

       themselves end up invoking drawing routines.

       Removing the cursor (rfbSpriteRemoveCursor) is eventually achieved by

       doing a CopyArea from a pixmap to the screen, where the pixmap contains

       the saved contents of the screen under the cursor.  Before doing this,

       however, we set cursorIsDrawn to FALSE.  Then, when CopyArea is called,

       it sees that cursorIsDrawn is FALSE and so doesn't feel the need to

       (recursively!) remove the cursor before doing it.

       Putting up the cursor (rfbSpriteRestoreCursor) involves a call to

       PushPixels.  While this is happening, cursorIsDrawn must be FALSE so

       that PushPixels doesn't think it has to remove the cursor first.

       Obviously cursorIsDrawn is set to TRUE afterwards.

       Another problem we face is that drawing routines sometimes cause a

       framebuffer update to be sent to the RFB client.  When the RFB client is

       already waiting for a framebuffer update and some drawing to the

       framebuffer then happens, the drawing routine sees that the client is

       ready, so it calls rfbSendFramebufferUpdate.  If the cursor is not drawn

       at this stage, it must be put up, and so rfbSpriteRestoreCursor is

       called.  However, if the original drawing routine was actually called

       from within rfbSpriteRestoreCursor or rfbSpriteRemoveCursor we don't

       want this to happen.  So both the cursor routines set

       dontSendFramebufferUpdate to TRUE, and all the drawing routines check

       this before calling rfbSendFramebufferUpdate. */

    Bool cursorIsDrawn;		    /* TRUE if the cursor is currently drawn */

    Bool dontSendFramebufferUpdate; /* TRUE while removing or drawing the

				       cursor */

    /* wrapped screen functions */

    CloseScreenProcPtr			CloseScreen;

    CreateGCProcPtr			CreateGC;

    PaintWindowBackgroundProcPtr	PaintWindowBackground;

    PaintWindowBorderProcPtr		PaintWindowBorder;

    CopyWindowProcPtr			CopyWindow;

    ClearToBackgroundProcPtr		ClearToBackground;

    RestoreAreasProcPtr			RestoreAreas;

    ScreenWakeupHandlerProcPtr 		WakeupHandler;

    InstallColormapProcPtr		InstallColormap;

    UninstallColormapProcPtr		UninstallColormap;

    ListInstalledColormapsProcPtr 	ListInstalledColormaps;

    StoreColorsProcPtr			StoreColors;

    DisplayCursorProcPtr		DisplayCursor;

    CursorPtr				pCurs;

    Bool				(*UseHWCursor)(ScreenPtr, CursorPtr);

    Bool				(*UseHWCursorARGB)(ScreenPtr, CursorPtr);

    Bool				*SWCursor;

#ifdef CHROMIUM

    RealizeWindowProcPtr		RealizeWindow;

    UnrealizeWindowProcPtr		UnrealizeWindow;

    DestroyWindowProcPtr		DestroyWindow;

    ResizeWindowProcPtr			ResizeWindow;

    PositionWindowProcPtr		PositionWindow;

    ClipNotifyProcPtr			ClipNotify;

#endif

#ifdef RENDER

    CompositeProcPtr			Composite;

#endif

} vncScreenRec, *vncScreenPtr;

extern Bool vncUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs);

extern Bool vncUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs);

extern void

rfbSendChromiumStart(unsigned int ipaddress, unsigned int port);

#endif /* _VNCINT_H_ */

if VNC

VNC_SUBDIRS = vnc

endif

# need to add darwin support here

	$(VNC_SUBDIRS)          \

/*

 * auth.c - deal with authentication.

 *

 * This file implements authentication when setting up an RFB connection.

 *

 * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk>

 */

/*

 *  Copyright (C) 2003-2004 Constantin Kaplinsky.  All Rights Reserved.

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

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 */

#ifdef HAVE_DIX_CONFIG_H

#include <dix-config.h>

#endif

#include "rfb.h"

#include "windowstr.h"

static void rfbSendSecurityType(rfbClientPtr cl, int securityType);

static void rfbSendSecurityTypeList(rfbClientPtr cl, int primaryType);

static void rfbSendTunnelingCaps(rfbClientPtr cl);

static void rfbSendAuthCaps(rfbClientPtr cl);

static void rfbVncAuthSendChallenge(rfbClientPtr cl);

/*

 * rfbAuthNewClient is called right after negotiating the protocol

 * version. Depending on the protocol version, we send either a code

 * for authentication scheme to be used (protocol 3.3), or a list of

 * possible "security types" (protocol 3.7).

 */

void

rfbAuthNewClient(cl)

    rfbClientPtr cl;

{

    VNCSCREENPTR(cl->pScreen);

    int securityType = rfbSecTypeInvalid;

    if ((!pVNC->rfbAuthPasswdFile && !pVNC->loginAuthEnabled) || cl->reverseConnection) {

	securityType = rfbSecTypeNone;

    } else {

	if (rfbAuthIsBlocked(cl)) {

	    rfbLog("Too many authentication failures - client rejected\n");

	    rfbClientConnFailed(cl, "Too many authentication failures");

	    return;

	}

	if (pVNC->rfbAuthPasswdFile)

	    securityType = rfbSecTypeVncAuth;

    }

    if (cl->protocol_minor_ver < 7) {

	/* Make sure we use only RFB 3.3 compatible security types. */

	if (securityType == rfbSecTypeInvalid) {

	    rfbLog("VNC authentication disabled - RFB 3.3 client rejected\n");

	    rfbClientConnFailed(cl, "Your viewer cannot handle required "

				"authentication methods");

	    return;

	}

	rfbSendSecurityType(cl, securityType);

    } else {

	/* Here it's ok when securityType is set to rfbSecTypeInvalid. */

	rfbSendSecurityTypeList(cl, securityType);

    }

}

/*

 * Tell the client what security type will be used (protocol 3.3).

 */

static void

rfbSendSecurityType(cl, securityType)

    rfbClientPtr cl;

    int securityType;

{

    CARD32 value32;

    /* Send the value. */

    value32 = Swap32IfLE(securityType);

    if (WriteExact(cl->sock, (char *)&value32, 4) < 0) {

	rfbLogPerror("rfbSendSecurityType: write");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    /* Decide what to do next. */

    switch (securityType) {

    case rfbSecTypeNone:

	/* Dispatch client input to rfbProcessClientInitMessage. */

	cl->state = RFB_INITIALISATION;

	break;

    case rfbSecTypeVncAuth:

	/* Begin the standard VNC authentication procedure. */

	rfbVncAuthSendChallenge(cl);

	break;

    default:

	/* Impossible case (hopefully). */

	rfbLogPerror("rfbSendSecurityType: assertion failed");

	rfbCloseSock(cl->pScreen, cl->sock);

    }

}

/*

 * Advertise our supported security types (protocol 3.7). The list

 * will include one standard security type (if primaryType is not set

 * to rfbSecTypeInvalid), and then one more value telling the client

 * that we support TightVNC protocol extensions. Thus, currently,

 * there will be either 1 or 2 items in the list.

 */

static void

rfbSendSecurityTypeList(cl, primaryType)

    rfbClientPtr cl;

    int primaryType;

{

    int count = 1;

    /* Fill in the list of security types in the client structure. */

    if (primaryType != rfbSecTypeInvalid) {

	cl->securityTypes[count++] = (CARD8)primaryType;

    }

    cl->securityTypes[count] = (CARD8)rfbSecTypeTight;

    cl->securityTypes[0] = (CARD8)count++;

    /* Send the list. */

    if (WriteExact(cl->sock, (char *)cl->securityTypes, count) < 0) {

	rfbLogPerror("rfbSendSecurityTypeList: write");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    /* Dispatch client input to rfbProcessClientSecurityType. */

    cl->state = RFB_SECURITY_TYPE;

}

/*

 * Read the security type chosen by the client (protocol 3.7).

 */

void

rfbProcessClientSecurityType(cl)

    rfbClientPtr cl;

{

    int n, count, i;

    CARD8 chosenType;

    /* Read the security type. */

    n = ReadExact(cl->sock, (char *)&chosenType, 1);

    if (n <= 0) {

	if (n == 0)

	    rfbLog("rfbProcessClientSecurityType: client gone\n");

	else

	    rfbLogPerror("rfbProcessClientSecurityType: read");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    /* Make sure it was present in the list sent by the server. */

    count = (int)cl->securityTypes[0];

    for (i = 1; i <= count; i++) {

	if (chosenType == cl->securityTypes[i])

	    break;

    }

    if (i > count) {

	rfbLog("rfbProcessClientSecurityType: "

	       "wrong security type requested\n");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    /* Now go to the proper authentication procedure. */

    switch (chosenType) {

    case rfbSecTypeNone:

	/* Dispatch client input to rfbProcessClientInitMessage. */

	cl->state = RFB_INITIALISATION;

	break;

    case rfbSecTypeVncAuth:

	/* Begin the standard VNC authentication procedure. */

	rfbVncAuthSendChallenge(cl);

	break;

    case rfbSecTypeTight:

	/* We are lucky: the viewer supports TightVNC extensions. */

	rfbLog("Enabling TightVNC protocol extensions\n");

	/* Switch to the protocol 3.7t. */

	cl->protocol_tightvnc = TRUE;

	/* Advertise our tunneling capabilities. */

	rfbSendTunnelingCaps(cl);

	break;

    default:

	/* Impossible case (hopefully). */

	rfbLog("rfbProcessClientSecurityType: "

	       "unknown authentication scheme\n");

	rfbCloseSock(cl->pScreen, cl->sock);

    }

}

/*

 * Send the list of our tunneling capabilities (protocol 3.7t).

 */

static void

rfbSendTunnelingCaps(cl)

    rfbClientPtr cl;

{

    rfbTunnelingCapsMsg caps;

    CARD32 nTypes = 0;		/* we don't support tunneling yet */

    caps.nTunnelTypes = Swap32IfLE(nTypes);

    if (WriteExact(cl->sock, (char *)&caps, sz_rfbTunnelingCapsMsg) < 0) {

	rfbLogPerror("rfbSendTunnelingCaps: write");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    if (nTypes) {

	/* Dispatch client input to rfbProcessClientTunnelingType(). */

	cl->state = RFB_TUNNELING_TYPE;

    } else {

	rfbSendAuthCaps(cl);

    }

}

/*

 * Read tunneling type requested by the client (protocol 3.7t).

 * NOTE: Currently, we don't support tunneling, and this function

 *       can never be called.

 */

void

rfbProcessClientTunnelingType(cl)

    rfbClientPtr cl;

{

    /* If we were called, then something's really wrong. */

    rfbLog("rfbProcessClientTunnelingType: not implemented\n");

    rfbCloseSock(cl->pScreen, cl->sock);

    return;

}

/*

 * Send the list of our authentication capabilities to the client

 * (protocol 3.7t).

 */

static void

rfbSendAuthCaps(cl)

    rfbClientPtr cl;

{

    VNCSCREENPTR(cl->pScreen);

    Bool authRequired;

    rfbAuthenticationCapsMsg caps;

    rfbCapabilityInfo caplist[MAX_AUTH_CAPS];

    int count = 0;

    authRequired = ((pVNC->rfbAuthPasswdFile != NULL || pVNC->loginAuthEnabled) &&

		    !cl->reverseConnection);

    if (authRequired) {

	if (pVNC->loginAuthEnabled) {

	    SetCapInfo(&caplist[count], rfbAuthUnixLogin, rfbTightVncVendor);

	    cl->authCaps[count++] = rfbAuthUnixLogin;

	}

	if (pVNC->rfbAuthPasswdFile != NULL) {

	    SetCapInfo(&caplist[count], rfbAuthVNC, rfbStandardVendor);

	    cl->authCaps[count++] = rfbAuthVNC;

	}

	if (count == 0) {

	    /* Should never happen. */

	    rfbLog("rfbSendAuthCaps: assertion failed\n");

     	    rfbCloseSock(cl->pScreen, cl->sock);

 	    return;

 	}

    }

    cl->nAuthCaps = count;

    caps.nAuthTypes = Swap32IfLE((CARD32)count);

    if (WriteExact(cl->sock, (char *)&caps, sz_rfbAuthenticationCapsMsg) < 0) {

	rfbLogPerror("rfbSendAuthCaps: write");

     	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    if (count) {

	if (WriteExact(cl->sock, (char *)&caplist[0],

		       count * sz_rfbCapabilityInfo) < 0) {

	    rfbLogPerror("rfbSendAuthCaps: write");

	    rfbCloseSock(cl->pScreen, cl->sock);

	    return;

	}

	/* Dispatch client input to rfbProcessClientAuthType. */

	cl->state = RFB_AUTH_TYPE;

     } else {

	/* Dispatch client input to rfbProcessClientInitMessage. */

	cl->state = RFB_INITIALISATION;

    }

}

/*

 * Read client's preferred authentication type (protocol 3.7t).

 */

void

rfbProcessClientAuthType(cl)

    rfbClientPtr cl;

{

    CARD32 auth_type;

    int n, i;

    /* Read authentication type selected by the client. */

    n = ReadExact(cl->sock, (char *)&auth_type, sizeof(auth_type));

    if (n <= 0) {

	if (n == 0)

	    rfbLog("rfbProcessClientAuthType: client gone\n");

	else

	    rfbLogPerror("rfbProcessClientAuthType: read");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    auth_type = Swap32IfLE(auth_type);

    /* Make sure it was present in the list sent by the server. */

    for (i = 0; i < cl->nAuthCaps; i++) {

	if (auth_type == cl->authCaps[i])

	    break;

    }

    if (i >= cl->nAuthCaps) {

	rfbLog("rfbProcessClientAuthType: "

	       "wrong authentication type requested\n");

     	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    switch (auth_type) {

    case rfbAuthNone:

	/* Dispatch client input to rfbProcessClientInitMessage. */

 	cl->state = RFB_INITIALISATION;

	break;

    case rfbAuthVNC:

	rfbVncAuthSendChallenge(cl);

	break;

    case rfbAuthUnixLogin:

	/* FIXME: Do (cl->state = RFB_LOGIN_AUTH) instead? */

	rfbLoginAuthProcessClientMessage(cl);

	break;

    default:

	rfbLog("rfbProcessClientAuthType: unknown authentication scheme\n");

     	rfbCloseSock(cl->pScreen, cl->sock);

     }

}

/*

 * Send the authentication challenge.

 */

static void

rfbVncAuthSendChallenge(cl)

    rfbClientPtr cl;

{

    vncRandomBytes(cl->authChallenge);

    if (WriteExact(cl->sock, (char *)cl->authChallenge, CHALLENGESIZE) < 0) {

	rfbLogPerror("rfbVncAuthSendChallenge: write");

     	rfbCloseSock(cl->pScreen, cl->sock);

 	return;

     }

    /* Dispatch client input to rfbVncAuthProcessResponse. */

    cl->state = RFB_AUTHENTICATION;

}

/*

 * rfbVncAuthProcessResponse is called when the client sends its

 * authentication response.

 */

void

rfbVncAuthProcessResponse(cl)

    rfbClientPtr cl;

{

    VNCSCREENPTR(cl->pScreen);

    char passwdFullControl[9];

    char passwdViewOnly[9];

    int numPasswords;

    Bool ok;

    int n;

    CARD8 encryptedChallenge1[CHALLENGESIZE];

    CARD8 encryptedChallenge2[CHALLENGESIZE];

    CARD8 response[CHALLENGESIZE];

    CARD32 authResult;

    n = ReadExact(cl->sock, (char *)response, CHALLENGESIZE);

    if (n <= 0) {

	if (n != 0)

	    rfbLogPerror("rfbVncAuthProcessResponse: read");

     	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    numPasswords = vncDecryptPasswdFromFile2(pVNC->rfbAuthPasswdFile,

					     passwdFullControl,

					     passwdViewOnly);

    if (numPasswords == 0) {

	rfbLog("rfbVncAuthProcessResponse: could not get password from %s\n",

	       pVNC->rfbAuthPasswdFile);

	authResult = Swap32IfLE(rfbVncAuthFailed);

	if (WriteExact(cl->sock, (char *)&authResult, 4) < 0) {

	    rfbLogPerror("rfbVncAuthProcessResponse: write");

	}

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    memcpy(encryptedChallenge1, cl->authChallenge, CHALLENGESIZE);

    vncEncryptBytes(encryptedChallenge1, passwdFullControl);

    memcpy(encryptedChallenge2, cl->authChallenge, CHALLENGESIZE);

    vncEncryptBytes(encryptedChallenge2,

		    (numPasswords == 2) ? passwdViewOnly : passwdFullControl);

    /* Lose the passwords from memory */

    memset(passwdFullControl, 0, 9);

    memset(passwdViewOnly, 0, 9);

    ok = FALSE;

    if (memcmp(encryptedChallenge1, response, CHALLENGESIZE) == 0) {

	rfbLog("Full-control authentication passed by %s\n", cl->host);

	ok = TRUE;

	cl->viewOnly = FALSE;

    } else if (memcmp(encryptedChallenge2, response, CHALLENGESIZE) == 0) {

	rfbLog("View-only authentication passed by %s\n", cl->host);

	ok = TRUE;

	cl->viewOnly = TRUE;

    }

    if (!ok) {

	rfbLog("rfbVncAuthProcessResponse: authentication failed from %s\n",

	       cl->host);

	if (rfbAuthConsiderBlocking(cl)) {

	    authResult = Swap32IfLE(rfbVncAuthTooMany);

	} else {

	    authResult = Swap32IfLE(rfbVncAuthFailed);

	}

	if (WriteExact(cl->sock, (char *)&authResult, 4) < 0) {

	    rfbLogPerror("rfbVncAuthProcessResponse: write");

	}

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    rfbAuthUnblock(cl);

    authResult = Swap32IfLE(rfbVncAuthOK);

    if (WriteExact(cl->sock, (char *)&authResult, 4) < 0) {

	rfbLogPerror("rfbVncAuthProcessResponse: write");

	rfbCloseSock(cl->pScreen, cl->sock);

	return;

    }

    /* Dispatch client input to rfbProcessClientInitMessage(). */

    cl->state = RFB_INITIALISATION;

}

/*

 * Functions to prevent too many successive authentication failures.

 * FIXME: This should be performed separately per each client IP.

 */

/* Maximum authentication failures before blocking connections */

#define MAX_AUTH_TRIES 5

/* Delay in ms, doubles for each failure over MAX_AUTH_TRIES */

#define AUTH_TOO_MANY_BASE_DELAY 10 * 1000

/*

 * This function should not be called directly, it is called by

 * setting a timer in rfbAuthConsiderBlocking().

 */

static CARD32

rfbAuthReenable(OsTimerPtr timer, CARD32 now, pointer arg)

{

    rfbClientPtr cl = (rfbClientPtr) arg;

    VNCSCREENPTR(cl->pScreen);

    (void)cl;

    pVNC->rfbAuthTooManyTries = FALSE;

    return 0;

}

/*

 * This function should be called after each authentication failure.

 * The return value will be true if there was too many failures.

 */

Bool

rfbAuthConsiderBlocking(rfbClientPtr cl)

{

    VNCSCREENPTR(cl->pScreen);

    int i;

    pVNC->rfbAuthTries++;

    if (pVNC->rfbAuthTries >= MAX_AUTH_TRIES) {

	CARD32 delay = AUTH_TOO_MANY_BASE_DELAY;

	for (i = MAX_AUTH_TRIES; i < pVNC->rfbAuthTries; i++)

	    delay *= 2;

	pVNC->timer = TimerSet(pVNC->timer, 0, delay, rfbAuthReenable, cl);

	pVNC->rfbAuthTooManyTries = TRUE;

	return TRUE;

    }

    return FALSE;

}

/*

 * This function should be called after successful authentication.

 * It resets the counter of authentication failures. Note that it's

 * not necessary to clear the rfbAuthTooManyTries flag as it will be

 * reset by the timer function.

 */

void

rfbAuthUnblock(rfbClientPtr cl)

{

    VNCSCREENPTR(cl->pScreen);

    pVNC->rfbAuthTries = 0;

}

/*

 * This function should be called before authentication process.

 * The return value will be true if there was too many authentication

 * failures, and the server should not allow another try.

 */

Bool

rfbAuthIsBlocked(rfbClientPtr cl)

{

    VNCSCREENPTR(cl->pScreen);

    return pVNC->rfbAuthTooManyTries;

}

/*

 * cmap.c

 *

 * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk>

 */

/*

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

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 */

/*

Copyright (c) 1993  X Consortium

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

"Software"), to deal in the Software without restriction, including

without limitation the rights to use, copy, modify, merge, publish,

distribute, sublicense, and/or sell copies of the Software, and to

permit persons to whom the Software is furnished to do so, subject to

the following conditions:

The above copyright notice and this permission notice shall be included

in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR

OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall

not be used in advertising or otherwise to promote the sale, use or

other dealings in this Software without prior written authorization

from the X Consortium.

*/

#ifdef HAVE_DIX_CONFIG_H

#include <dix-config.h>

#endif

#include "rfb.h"

int

rfbListInstalledColormaps(pScreen, pmaps)

    ScreenPtr	pScreen;

    Colormap	*pmaps;

{

    VNCSCREENPTR(pScreen);

    /* By the time we are processing requests, we can guarantee that there

     * is always a colormap installed */

    if (pVNC->rfbInstalledColormap)

    	*pmaps = pVNC->rfbInstalledColormap->mid;

#if XFREE86VNC

    pScreen->ListInstalledColormaps = pVNC->ListInstalledColormaps;

    (*pScreen->ListInstalledColormaps)(pScreen, pmaps);

    pScreen->ListInstalledColormaps = rfbListInstalledColormaps;

#endif

    return (1);

}

void

rfbInstallColormap(pmap)

    ColormapPtr	pmap;

{

    VNCSCREENPTR(pmap->pScreen);

    if (pmap != pVNC->rfbInstalledColormap) {

	if(pVNC->rfbInstalledColormap != (ColormapPtr)None)

	    WalkTree(pmap->pScreen, TellLostMap,

				 (char *)&pVNC->rfbInstalledColormap->mid);

	/* Install pmap */

	pVNC->rfbInstalledColormap = pmap;

	WalkTree(pmap->pScreen, TellGainedMap, (char *)&pmap->mid);

	rfbSetClientColourMaps(0, 0);

    }

#if XFREE86VNC

    pmap->pScreen->InstallColormap = pVNC->InstallColormap;

    (*pmap->pScreen->InstallColormap)(pmap);

    pmap->pScreen->InstallColormap = rfbInstallColormap;

#endif

}

void

rfbUninstallColormap(pmap)

    ColormapPtr	pmap;

{

    VNCSCREENPTR(pmap->pScreen);

    if(pmap == pVNC->rfbInstalledColormap)

    {

	if (pmap->mid != pmap->pScreen->defColormap)

	{

	    pVNC->rfbInstalledColormap = 

			(ColormapPtr) LookupIDByType(pmap->pScreen->defColormap,

						   RT_COLORMAP);

	    (*pmap->pScreen->InstallColormap)(pVNC->rfbInstalledColormap);

	}

    }

#if XFREE86VNC

    pmap->pScreen->UninstallColormap = pVNC->UninstallColormap;

    (*pmap->pScreen->UninstallColormap)(pmap);

    pmap->pScreen->UninstallColormap = rfbUninstallColormap;

#endif

}

/*

 * rfbStoreColors.  We have a set of pixels but they may be in any order.

 * If some of them happen to be in continuous ascending order then we can

 * group them together into a single call to rfbSetClientColourMaps.

 */

void

rfbStoreColors(pmap, ndef, pdefs)

    ColormapPtr pmap;

    int         ndef;

    xColorItem  *pdefs;

{

    VNCSCREENPTR(pmap->pScreen);

    int i;

    int first = -1;

    int n = 0;

    if (pmap == pVNC->rfbInstalledColormap) {

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

	    if ((first != -1) && (first + n == pdefs[i].pixel)) {

		n++;

	    } else {

		if (first != -1) {

		    rfbSetClientColourMaps(first, n);

		}

		first = pdefs[i].pixel;

		n = 1;

	    }

	}

	rfbSetClientColourMaps(first, n);

    }

#if XFREE86VNC

    pmap->pScreen->StoreColors = pVNC->StoreColors;

    (*pmap->pScreen->StoreColors)(pmap, ndef, pdefs);

    pmap->pScreen->StoreColors = rfbStoreColors;

#endif

}

/*

 * corre.c

 *

 * Routines to implement Compact Rise-and-Run-length Encoding (CoRRE).  This

 * code is based on krw's original javatel rfbserver.

 *

 * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk>

 */

/*

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

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 */

#ifdef HAVE_DIX_CONFIG_H

#include <dix-config.h>

#endif

#include <stdio.h>

#include "rfb.h"

/*

 * rreBeforeBuf contains pixel data in the client's format.

 * rreAfterBuf contains the RRE encoded version.  If the RRE encoded version is

 * larger than the raw data or if it exceeds rreAfterBufSize then

 * raw encoding is used instead.

 */

static int rreBeforeBufSize = 0;

static unsigned char *rreBeforeBuf = NULL;

static int rreAfterBufSize = 0;

static unsigned char *rreAfterBuf = NULL;

static int rreAfterBufLen;

static int subrectEncode8(CARD8 *data, int w, int h);

static int subrectEncode16(CARD16 *data, int w, int h);

static int subrectEncode32(CARD32 *data, int w, int h);

static CARD32 getBgColour(char *data, int size, int bpp);

static Bool rfbSendSmallRectEncodingCoRRE(rfbClientPtr cl, int x, int y,

					  int w, int h);

/*

 * rfbSendRectEncodingCoRRE - send an arbitrary size rectangle using CoRRE

 * encoding.

 */

Bool

rfbSendRectEncodingCoRRE(cl, x, y, w, h)

    rfbClientPtr cl;

    int x, y, w, h;

{

    if (h > cl->correMaxHeight) {

	return (rfbSendRectEncodingCoRRE(cl, x, y, w, cl->correMaxHeight) &&

		rfbSendRectEncodingCoRRE(cl, x, y + cl->correMaxHeight,

					 w, h - cl->correMaxHeight));

    }

    if (w > cl->correMaxWidth) {

	return (rfbSendRectEncodingCoRRE(cl, x, y, cl->correMaxWidth, h) &&

		rfbSendRectEncodingCoRRE(cl, x + cl->correMaxWidth, y,

					 w - cl->correMaxWidth, h));

    }

    return rfbSendSmallRectEncodingCoRRE(cl, x, y, w, h);

}

/*

 * rfbSendSmallRectEncodingCoRRE - send a small (guaranteed < 256x256)

 * rectangle using CoRRE encoding.

 */

static Bool

rfbSendSmallRectEncodingCoRRE(cl, x, y, w, h)

    rfbClientPtr cl;

    int x, y, w, h;

{

    VNCSCREENPTR(cl->pScreen);

    rfbFramebufferUpdateRectHeader rect;

    rfbRREHeader hdr;

    int nSubrects;

    int i;

    int maxRawSize = (pVNC->width * pVNC->height

		      * (cl->format.bitsPerPixel / 8));

    if (rreBeforeBufSize < maxRawSize) {

	rreBeforeBufSize = maxRawSize;

	if (rreBeforeBuf == NULL)

	    rreBeforeBuf = (unsigned char *)xalloc(rreBeforeBufSize);

	else

	    rreBeforeBuf = (unsigned char *)xrealloc(rreBeforeBuf, rreBeforeBufSize);

    }

    if (rreAfterBufSize < maxRawSize) {

	rreAfterBufSize = maxRawSize;

	if (rreAfterBuf == NULL)

	    rreAfterBuf = (unsigned char *)xalloc(rreAfterBufSize);

	else

	    rreAfterBuf = (unsigned char *)xrealloc(rreAfterBuf, rreAfterBufSize);

    }

    (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, 

		       &pVNC->rfbServerFormat,

		       &cl->format, rreBeforeBuf,

		       pVNC->paddedWidthInBytes, w, h, x, y);

    switch (cl->format.bitsPerPixel) {

    case 8:

	nSubrects = subrectEncode8((CARD8 *)rreBeforeBuf, w, h);

	break;

    case 16:

	nSubrects = subrectEncode16((CARD16 *)rreBeforeBuf, w, h);

	break;

    case 32:

	nSubrects = subrectEncode32((CARD32 *)rreBeforeBuf, w, h);

	break;

    default:

	rfbLog("getBgColour: bpp %d?\n",cl->format.bitsPerPixel);

	exit(1);

    }

    if (nSubrects < 0) {

	/* RRE encoding was too large, use raw */

	return rfbSendRectEncodingRaw(cl, x, y, w, h);

    }

    cl->rfbRectanglesSent[rfbEncodingCoRRE]++;

    cl->rfbBytesSent[rfbEncodingCoRRE] += (sz_rfbFramebufferUpdateRectHeader

					   + sz_rfbRREHeader + rreAfterBufLen);

    if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbRREHeader

	> UPDATE_BUF_SIZE)

    {

	if (!rfbSendUpdateBuf(cl))

	    return FALSE;

    }

    rect.r.x = Swap16IfLE(x);