Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
DISCONTINUED:openSUSE:11.1:Update
xorg-x11-server-dmx
xorg-server-1.4-vnc.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File xorg-server-1.4-vnc.patch of Package xorg-x11-server-dmx
Diff from xf4vnc 2007-09-06 - xserver 265a633cf1fcbf497d6916d9e22403dffdde2e07 plus a couple missing commits to clean up the diff. Provides Xvnc and vnc.so extension. Requires vncproto, xcliplistproto and libXcliplist also from xf4vnc. Requires autotools rebuild. diff -pNur xorg-server-1.4.orig/configure.ac xorg-server-1.4/configure.ac --- xorg-server-1.4.orig/configure.ac 2007-09-05 22:59:00.000000000 -0700 +++ xorg-server-1.4/configure.ac 2007-09-06 16:09:51.000000000 -0700 @@ -518,6 +518,10 @@ AC_ARG_ENABLE(xfree86-utils, AS_HELP dnl DDXes. AC_ARG_ENABLE(xorg, AS_HELP_STRING([--enable-xorg], [Build Xorg server (default: auto)]), [XORG=$enableval], [XORG=auto]) AC_ARG_ENABLE(dmx, AS_HELP_STRING([--enable-dmx], [Build DMX server (default: no)]), [DMX=$enableval], [DMX=no]) + +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]) + AC_ARG_ENABLE(xvfb, AS_HELP_STRING([--enable-xvfb], [Build Xvfb server (default: yes)]), [XVFB=$enableval], [XVFB=yes]) AC_ARG_ENABLE(xnest, AS_HELP_STRING([--enable-xnest], [Build Xnest server (default: auto)]), [XNEST=$enableval], [XNEST=auto]) AC_ARG_ENABLE(xwin, AS_HELP_STRING([--enable-xwin], [Build XWin server (default: auto)]), [XWIN=$enableval], [XWIN=auto]) @@ -887,6 +891,20 @@ XI_INC='-I$(top_srcdir)/Xi' AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes) +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 + AC_DEFINE(SHAPE, 1, [Support SHAPE extension]) AC_DEFINE(XKB, 1, [Build XKB]) @@ -1000,6 +1018,8 @@ MI_EXT_LIB='$(top_builddir)/mi/libmiext. MI_INC='-I$(top_srcdir)/mi' FB_LIB='$(top_builddir)/fb/libfb.la' FB_INC='-I$(top_srcdir)/fb' +MFB_LIB='$(top_builddir)/mfb/libmfb.la' +MFB_INC='-I$(top_srcdir)/mfb' MIEXT_SHADOW_INC='-I$(top_srcdir)/miext/shadow' MIEXT_SHADOW_LIB='$(top_builddir)/miext/shadow/libshadow.la' XPSTUBS_LIB='$(top_builddir)/dix/libxpstubs.la' @@ -1162,6 +1182,40 @@ AM_CONDITIONAL([DMX_BUILD_LNX], [test "x AM_CONDITIONAL([DMX_BUILD_USB], [test "x$DMX_BUILD_USB" = xyes]) + +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 + + + dnl Xvfb DDX AC_MSG_CHECKING([whether to build Xvfb DDX]) @@ -2011,6 +2065,7 @@ Xext/Makefile Xi/Makefile xfixes/Makefile exa/Makefile +xcliplist/Makefile hw/Makefile hw/xfree86/Makefile hw/xfree86/common/Makefile @@ -2048,6 +2103,7 @@ hw/xfree86/scanpci/Makefile hw/xfree86/shadowfb/Makefile hw/xfree86/vbe/Makefile hw/xfree86/vgahw/Makefile +hw/xfree86/vnc/Makefile hw/xfree86/x86emu/Makefile hw/xfree86/xaa/Makefile hw/xfree86/xf1bpp/Makefile @@ -2068,8 +2124,10 @@ hw/dmx/doc/Makefile hw/dmx/examples/Makefile hw/dmx/input/Makefile hw/dmx/glxProxy/Makefile +hw/dmx/vnc/Makefile hw/dmx/Makefile hw/vfb/Makefile +hw/vnc/Makefile hw/xgl/Makefile hw/xgl/egl/Makefile hw/xgl/egl/module/Makefile diff -pNur xorg-server-1.4.orig/hw/dmx/dmx-config.h xorg-server-1.4/hw/dmx/dmx-config.h --- xorg-server-1.4.orig/hw/dmx/dmx-config.h 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/dmx-config.h 2007-09-06 16:09:45.000000000 -0700 @@ -72,6 +72,9 @@ /* Enable the DMX extension */ #define DMXEXT +/* Enable VNC ability */ +#define DMXVNC 1 + /* Disable the extensions that are not currently supported */ #undef BEZIER #undef PEXEXT diff -pNur xorg-server-1.4.orig/hw/dmx/dmxinit.c xorg-server-1.4/hw/dmx/dmxinit.c --- xorg-server-1.4.orig/hw/dmx/dmxinit.c 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/dmxinit.c 2007-09-06 16:09:45.000000000 -0700 @@ -77,6 +77,10 @@ extern void GlxSetVisualConfigs( ); #endif /* GLXEXT */ +#ifdef DMXVNC +extern void VNCInitForDMX(void); +#endif + /* Global variables available to all Xserver/hw/dmx routines. */ int dmxNumScreens; DMXScreenInfo *dmxScreens; @@ -812,6 +816,9 @@ void InitOutput(ScreenInfo *pScreenInfo, dmxLog(dmxInfo, "Shadow framebuffer support %s\n", dmxShadowFB ? "enabled" : "disabled"); +#ifdef DMXVNC + VNCInitForDMX(); +#endif } /* RATS: Assuming the fp string (which comes from the command-line argv @@ -1045,3 +1052,14 @@ void ddxUseMsg(void) ErrorF(" Ctrl-Alt-q Quit (core devices only)\n"); ErrorF(" Ctrl-Alt-F* Switch to VC (local only)\n"); } + +#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 diff -pNur xorg-server-1.4.orig/hw/dmx/dmxsync.c xorg-server-1.4/hw/dmx/dmxsync.c --- xorg-server-1.4.orig/hw/dmx/dmxsync.c 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/dmxsync.c 2007-09-06 16:09:45.000000000 -0700 @@ -99,9 +99,16 @@ static void dmxSyncBlockHandler(pointer TimerForce(dmxSyncTimer); } +#ifdef DMXVNC +extern void rfbWakeupHandlerDMX(void); +#endif + static void dmxSyncWakeupHandler(pointer blockData, int result, pointer pReadMask) { +#ifdef DMXVNC + rfbWakeupHandlerDMX(); +#endif } /** Request the XSync() batching optimization with the specified \a diff -pNur xorg-server-1.4.orig/hw/dmx/input/dmxcommon.c xorg-server-1.4/hw/dmx/input/dmxcommon.c --- xorg-server-1.4.orig/hw/dmx/input/dmxcommon.c 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/input/dmxcommon.c 2007-09-06 16:09:45.000000000 -0700 @@ -655,7 +655,6 @@ void dmxCommonRestoreState(pointer priva dmxLogInput(dmxInput, "Keyboard busy, waiting\n"); else dmxLogInput(dmxInput, "Keyboard error, waiting\n"); - /* Don't generate X11 protocol for a bit */ for (tmp = GetTimeInMillis(); GetTimeInMillis() - tmp < 250;) { usleep(250); /* This ends up sleeping only until diff -pNur xorg-server-1.4.orig/hw/dmx/input/dmxinputinit.c xorg-server-1.4/hw/dmx/input/dmxinputinit.c --- xorg-server-1.4.orig/hw/dmx/input/dmxinputinit.c 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/input/dmxinputinit.c 2007-09-06 16:09:45.000000000 -0700 @@ -393,6 +393,10 @@ static int dmxKeyboardOn(DeviceIntPtr pD DevicePtr pDev = &pDevice->public; #endif +#ifdef DMXVNC + vncSetKeyboardDevice(pDevice); +#endif + #ifdef XKB if (noXkbExtension) { #endif @@ -480,6 +484,10 @@ static int dmxDeviceOnOff(DeviceIntPtr p break; } if (info.keyClass) { +#ifdef DMXVNC + vncSetKeyboardDevice(pDevice); +#endif + #if 00 /*BP*/ InitKeyClassDeviceStruct(pDevice, &info.keySyms, info.modMap); #else @@ -534,6 +542,9 @@ static int dmxDeviceOnOff(DeviceIntPtr p info.maxres[i+1]); #endif } +#ifdef DMXVNC + vncSetPointerDevice(pDevice); +#endif } if (info.focusClass) InitFocusClassDeviceStruct(pDevice); #ifdef XINPUT diff -pNur xorg-server-1.4.orig/hw/dmx/input/dmxinputinit.h xorg-server-1.4/hw/dmx/input/dmxinputinit.h --- xorg-server-1.4.orig/hw/dmx/input/dmxinputinit.h 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/input/dmxinputinit.h 2007-09-06 16:09:45.000000000 -0700 @@ -290,4 +290,9 @@ extern int dmxInputAttachConsol extern int dmxInputAttachBackend(int physicalScreen, int isCore, int *id); +#ifdef DMXVNC +extern void vncSetKeyboardDevice(DeviceIntPtr kbd); +extern void vncSetPointerDevice(DeviceIntPtr ptr); +#endif + #endif diff -pNur xorg-server-1.4.orig/hw/dmx/input/Makefile.am xorg-server-1.4/hw/dmx/input/Makefile.am --- xorg-server-1.4.orig/hw/dmx/input/Makefile.am 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/hw/dmx/input/Makefile.am 2007-09-06 16:09:45.000000000 -0700 @@ -65,6 +65,7 @@ AM_CFLAGS = $(DIX_CFLAGS) \ -I$(top_srcdir)/hw/xfree86/common \ $(GLX_INCS) \ -DHAVE_DMX_CONFIG_H \ + -DDMXVNC=1 \ $(GLX_DEFS) \ @DMXMODULES_CFLAGS@ diff -pNur xorg-server-1.4.orig/hw/dmx/vnc/Makefile.am xorg-server-1.4/hw/dmx/vnc/Makefile.am --- xorg-server-1.4.orig/hw/dmx/vnc/Makefile.am 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/dmx/vnc/Makefile.am 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,43 @@ +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 diff -pNur xorg-server-1.4.orig/hw/dmx/vnc/vncInit.c xorg-server-1.4/hw/dmx/vnc/vncInit.c --- xorg-server-1.4.orig/hw/dmx/vnc/vncInit.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/dmx/vnc/vncInit.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,453 @@ +/* + * 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); +} diff -pNur xorg-server-1.4.orig/hw/dmx/vnc/vncint.h xorg-server-1.4/hw/dmx/vnc/vncint.h --- xorg-server-1.4.orig/hw/dmx/vnc/vncint.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/dmx/vnc/vncint.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,153 @@ +/* + * 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_ */ + diff -pNur xorg-server-1.4.orig/hw/vnc/auth.c xorg-server-1.4/hw/vnc/auth.c --- xorg-server-1.4.orig/hw/vnc/auth.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/auth.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,566 @@ +/* + * 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; +} + diff -pNur xorg-server-1.4.orig/hw/vnc/cmap.c xorg-server-1.4/hw/vnc/cmap.c --- xorg-server-1.4.orig/hw/vnc/cmap.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/cmap.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,166 @@ +/* + * 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 +} diff -pNur xorg-server-1.4.orig/hw/vnc/corre.c xorg-server-1.4/hw/vnc/corre.c --- xorg-server-1.4.orig/hw/vnc/corre.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/corre.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,353 @@ +/* + * 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); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingCoRRE); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + hdr.nSubrects = Swap32IfLE(nSubrects); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&hdr, sz_rfbRREHeader); + pVNC->ublen += sz_rfbRREHeader; + + for (i = 0; i < rreAfterBufLen;) { + + int bytesToCopy = UPDATE_BUF_SIZE - pVNC->ublen; + + if (i + bytesToCopy > rreAfterBufLen) { + bytesToCopy = rreAfterBufLen - i; + } + + memcpy(&pVNC->updateBuf[pVNC->ublen], &rreAfterBuf[i], bytesToCopy); + + pVNC->ublen += bytesToCopy; + i += bytesToCopy; + + if (pVNC->ublen == UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + } + + return TRUE; +} + + + +/* + * subrectEncode() encodes the given multicoloured rectangle as a background + * colour overwritten by single-coloured rectangles. It returns the number + * of subrectangles in the encoded buffer, or -1 if subrect encoding won't + * fit in the buffer. It puts the encoded rectangles in rreAfterBuf. The + * single-colour rectangle partition is not optimal, but does find the biggest + * horizontal or vertical rectangle top-left anchored to each consecutive + * coordinate position. + * + * The coding scheme is simply [<bgcolour><subrect><subrect>...] where each + * <subrect> is [<colour><x><y><w><h>]. + */ + +#define DEFINE_SUBRECT_ENCODE(bpp) \ +static int \ +subrectEncode##bpp(data,w,h) \ + CARD##bpp *data; \ + int w; \ + int h; \ +{ \ + CARD##bpp cl; \ + rfbCoRRERectangle subrect; \ + int x,y; \ + int i,j; \ + int hx=0,hy,vx=0,vy; \ + int hyflag; \ + CARD##bpp *seg; \ + CARD##bpp *line; \ + int hw,hh,vw,vh; \ + int thex,they,thew,theh; \ + int numsubs = 0; \ + int newLen; \ + CARD##bpp bg = (CARD##bpp)getBgColour((char*)data,w*h,bpp); \ + \ + *((CARD##bpp*)rreAfterBuf) = bg; \ + \ + rreAfterBufLen = (bpp/8); \ + \ + for (y=0; y<h; y++) { \ + line = data+(y*w); \ + for (x=0; x<w; x++) { \ + if (line[x] != bg) { \ + cl = line[x]; \ + hy = y-1; \ + hyflag = 1; \ + for (j=y; j<h; j++) { \ + seg = data+(j*w); \ + if (seg[x] != cl) {break;} \ + i = x; \ + while ((seg[i] == cl) && (i < w)) i += 1; \ + i -= 1; \ + if (j == y) vx = hx = i; \ + if (i < vx) vx = i; \ + if ((hyflag > 0) && (i >= hx)) {hy += 1;} else {hyflag = 0;} \ + } \ + vy = j-1; \ + \ + /* We now have two possible subrects: (x,y,hx,hy) and (x,y,vx,vy) \ + * We'll choose the bigger of the two. \ + */ \ + hw = hx-x+1; \ + hh = hy-y+1; \ + vw = vx-x+1; \ + vh = vy-y+1; \ + \ + thex = x; \ + they = y; \ + \ + if ((hw*hh) > (vw*vh)) { \ + thew = hw; \ + theh = hh; \ + } else { \ + thew = vw; \ + theh = vh; \ + } \ + \ + subrect.x = thex; \ + subrect.y = they; \ + subrect.w = thew; \ + subrect.h = theh; \ + \ + newLen = rreAfterBufLen + (bpp/8) + sz_rfbCoRRERectangle; \ + if ((newLen > (w * h * (bpp/8))) || (newLen > rreAfterBufSize)) \ + return -1; \ + \ + numsubs += 1; \ + *((CARD##bpp*)(rreAfterBuf + rreAfterBufLen)) = cl; \ + rreAfterBufLen += (bpp/8); \ + memcpy(&rreAfterBuf[rreAfterBufLen],&subrect,sz_rfbCoRRERectangle); \ + rreAfterBufLen += sz_rfbCoRRERectangle; \ + \ + /* \ + * Now mark the subrect as done. \ + */ \ + for (j=they; j < (they+theh); j++) { \ + for (i=thex; i < (thex+thew); i++) { \ + data[j*w+i] = bg; \ + } \ + } \ + } \ + } \ + } \ + \ + return numsubs; \ +} + +DEFINE_SUBRECT_ENCODE(8) +DEFINE_SUBRECT_ENCODE(16) +DEFINE_SUBRECT_ENCODE(32) + + +/* + * getBgColour() gets the most prevalent colour in a byte array. + */ +static CARD32 +getBgColour(data,size,bpp) + char *data; + int size; + int bpp; +{ + +#define NUMCLRS 256 + + static int counts[NUMCLRS]; + int i,j,k; + + int maxcount = 0; + CARD8 maxclr = 0; + + if (bpp != 8) { + if (bpp == 16) { + return ((CARD16 *)data)[0]; + } else if (bpp == 32) { + return ((CARD32 *)data)[0]; + } else { + rfbLog("getBgColour: bpp %d?\n",bpp); + exit(1); + } + } + + for (i=0; i<NUMCLRS; i++) { + counts[i] = 0; + } + + for (j=0; j<size; j++) { + k = (int)(((CARD8 *)data)[j]); + if (k >= NUMCLRS) { + rfbLog("getBgColour: unusual colour = %d\n", k); + exit(1); + } + counts[k] += 1; + if (counts[k] > maxcount) { + maxcount = counts[k]; + maxclr = ((CARD8 *)data)[j]; + } + } + + return maxclr; +} diff -pNur xorg-server-1.4.orig/hw/vnc/cursor.c xorg-server-1.4/hw/vnc/cursor.c --- xorg-server-1.4.orig/hw/vnc/cursor.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/cursor.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,407 @@ +/* + * cursor.c - support for cursor shape updates. + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2000, 2001 Const 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 <stdio.h> +#include "rfb.h" +#include "mipointer.h" +#include "sprite.h" +#include "cursorstr.h" +#include "servermd.h" + + +/* Copied from Xvnc/lib/font/util/utilbitmap.c */ +static unsigned char _reverse_byte[0x100] = { + 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, + 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, + 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, + 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, + 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, + 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, + 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, + 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, + 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, + 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, + 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, + 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, + 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, + 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, + 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, + 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, + 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, + 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, + 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, + 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, + 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, + 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, + 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, + 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, + 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, + 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, + 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, + 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, + 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, + 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, + 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, + 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff +}; + + +static int EncodeRichCursorData8 (unsigned char *buf, rfbPixelFormat *fmt, + CursorPtr pCursor); +static int EncodeRichCursorData16 (ScreenPtr pScreen, + unsigned char *buf, rfbPixelFormat *fmt, + CursorPtr pCursor); +static int EncodeRichCursorData32 (ScreenPtr pScreen, + unsigned char *buf, rfbPixelFormat *fmt, + CursorPtr pCursor); + + +/* + * Send cursor shape either in X-style format or in client pixel format. + */ + +Bool +rfbSendCursorShape(cl, pScreen) + rfbClientPtr cl; + ScreenPtr pScreen; +{ + VNCSCREENPTR(pScreen); + CursorPtr pCursor; + rfbFramebufferUpdateRectHeader rect; + rfbXCursorColors colors; + int saved_ublen; + int bitmapRowBytes, paddedRowBytes, maskBytes, dataBytes; + int i, j; + CARD8 *bitmapData; + CARD8 bitmapByte; + + if (cl->useRichCursorEncoding) { + rect.encoding = Swap32IfLE(rfbEncodingRichCursor); + } else { + rect.encoding = Swap32IfLE(rfbEncodingXCursor); + } + +#if XFREE86VNC + pCursor = pVNC->pCurs; +#else + pCursor = rfbSpriteGetCursorPtr(pScreen); +#endif + + /* If there is no cursor, send update with empty cursor data. */ + + if ( pCursor != NULL && + pCursor->bits->width == 1 && + pCursor->bits->height == 1 && + pCursor->bits->mask[0] == 0 ) { + pCursor = NULL; + } + + if (pCursor == NULL) { + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE ) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + rect.r.x = rect.r.y = 0; + rect.r.w = rect.r.h = 0; + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbCursorShapeBytesSent += sz_rfbFramebufferUpdateRectHeader; + cl->rfbCursorShapeUpdatesSent++; + + return TRUE; + } + + /* Calculate data sizes. */ + + bitmapRowBytes = (pCursor->bits->width + 7) / 8; + paddedRowBytes = PixmapBytePad(pCursor->bits->width, 1); + maskBytes = bitmapRowBytes * pCursor->bits->height; + dataBytes = (cl->useRichCursorEncoding) ? + (pCursor->bits->width * pCursor->bits->height * + (cl->format.bitsPerPixel / 8)) : maskBytes; + + /* Send buffer contents if needed. */ + + if ( pVNC->ublen + sz_rfbFramebufferUpdateRectHeader + + sz_rfbXCursorColors + maskBytes + dataBytes > UPDATE_BUF_SIZE ) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + if ( pVNC->ublen + sz_rfbFramebufferUpdateRectHeader + + sz_rfbXCursorColors + maskBytes + dataBytes > UPDATE_BUF_SIZE ) { + return FALSE; /* FIXME. */ + } + + saved_ublen = pVNC->ublen; + + /* Prepare rectangle header. */ + + rect.r.x = Swap16IfLE(pCursor->bits->xhot); + rect.r.y = Swap16IfLE(pCursor->bits->yhot); + rect.r.w = Swap16IfLE(pCursor->bits->width); + rect.r.h = Swap16IfLE(pCursor->bits->height); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect,sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + /* Prepare actual cursor data (depends on encoding used). */ + + if (!cl->useRichCursorEncoding) { + /* XCursor encoding. */ + colors.foreRed = (char)(pCursor->foreRed >> 8); + colors.foreGreen = (char)(pCursor->foreGreen >> 8); + colors.foreBlue = (char)(pCursor->foreBlue >> 8); + colors.backRed = (char)(pCursor->backRed >> 8); + colors.backGreen = (char)(pCursor->backGreen >> 8); + colors.backBlue = (char)(pCursor->backBlue >> 8); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&colors, sz_rfbXCursorColors); + pVNC->ublen += sz_rfbXCursorColors; + + bitmapData = (CARD8 *)pCursor->bits->source; + + for (i = 0; i < pCursor->bits->height; i++) { + for (j = 0; j < bitmapRowBytes; j++) { + bitmapByte = bitmapData[i * paddedRowBytes + j]; + if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = _reverse_byte[bitmapByte]; + } + pVNC->updateBuf[pVNC->ublen++] = (char)bitmapByte; + } + } + } else { + /* RichCursor encoding. */ + switch (cl->format.bitsPerPixel) { + case 8: + pVNC->ublen += EncodeRichCursorData8(&pVNC->updateBuf[pVNC->ublen], + &cl->format, pCursor); + break; + case 16: + pVNC->ublen += EncodeRichCursorData16(pScreen, &pVNC->updateBuf[pVNC->ublen], + &cl->format, pCursor); + break; + case 32: + pVNC->ublen += EncodeRichCursorData32(pScreen, &pVNC->updateBuf[pVNC->ublen], + &cl->format, pCursor); + break; + default: + return FALSE; + } + } + + /* Prepare transparency mask. */ + + bitmapData = (CARD8 *)pCursor->bits->mask; + + for (i = 0; i < pCursor->bits->height; i++) { + for (j = 0; j < bitmapRowBytes; j++) { + bitmapByte = bitmapData[i * paddedRowBytes + j]; + if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = _reverse_byte[bitmapByte]; + } + pVNC->updateBuf[pVNC->ublen++] = (char)bitmapByte; + } + } + + /* Update statistics. */ + + cl->rfbCursorShapeBytesSent += (pVNC->ublen - saved_ublen); + cl->rfbCursorShapeUpdatesSent++; + + return TRUE; +} + +/* + * Send cursor position (PointerPos pseudo-encoding). + */ +Bool +rfbSendCursorPos(cl, pScreen) + rfbClientPtr cl; + ScreenPtr pScreen; +{ + VNCSCREENPTR(pScreen); + rfbFramebufferUpdateRectHeader rect; +#if XFREE86VNC + ScreenPtr pCursorScreen = miPointerCurrentScreen(); /*XXX deprecated*/ +#endif + int x, y; + + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + +#if XFREE86VNC + if (pScreen == pCursorScreen) + miPointerPosition(&x, &y); +#else + rfbSpriteGetCursorPos(pScreen, &x, &y); +#endif + + rect.encoding = Swap32IfLE(rfbEncodingPointerPos); + rect.r.x = Swap16IfLE((CARD16)x); + rect.r.y = Swap16IfLE((CARD16)y); + rect.r.w = 0; + rect.r.h = 0; + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbCursorPosBytesSent += sz_rfbFramebufferUpdateRectHeader; + cl->rfbCursorPosUpdatesSent++; + + if (!rfbSendUpdateBuf(cl)) + return FALSE; + + cl->cursorX = x; + cl->cursorY = y; + + return TRUE; +} + +/* + * Code to convert cursor source bitmap to the desired pixel format. + */ + +#define RGB48_TO_PIXEL(fmt,r,g,b) \ + (((CARD32)(r) * ((fmt)->redMax + 1) >> 16) << (fmt)->redShift | \ + ((CARD32)(g) * ((fmt)->greenMax + 1) >> 16) << (fmt)->greenShift | \ + ((CARD32)(b) * ((fmt)->blueMax + 1) >> 16) << (fmt)->blueShift) + +static int +EncodeRichCursorData8(buf, fmt, pCursor) + unsigned char *buf; + rfbPixelFormat *fmt; + CursorPtr pCursor; +{ + int widthPixels, widthBytes; + int x, y, b; + CARD8 *src; + char pix[2]; + CARD8 bitmapByte; + + pix[0] = (char)RGB48_TO_PIXEL(fmt, pCursor->backRed, pCursor->backGreen, + pCursor->backBlue); + pix[1] = (char)RGB48_TO_PIXEL(fmt, pCursor->foreRed, pCursor->foreGreen, + pCursor->foreBlue); + + src = (CARD8 *)pCursor->bits->source; + widthPixels = pCursor->bits->width; + widthBytes = PixmapBytePad(widthPixels, 1); + + for (y = 0; y < pCursor->bits->height; y++) { + for (x = 0; x < widthPixels / 8; x++) { + bitmapByte = src[y * widthBytes + x]; + if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = _reverse_byte[bitmapByte]; + } + for (b = 7; b >= 0; b--) { + *buf++ = pix[bitmapByte >> b & 1]; + } + } + if (widthPixels % 8) { + bitmapByte = src[y * widthBytes + x]; + if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = _reverse_byte[bitmapByte]; + } + for (b = 7; b > 7 - widthPixels % 8; b--) { + *buf++ = pix[bitmapByte >> b & 1]; + } + } + } + + return (widthPixels * pCursor->bits->height); +} + +#define DEFINE_RICH_ENCODE(bpp) \ + \ +static int \ +EncodeRichCursorData##bpp(pScreen, buf, fmt, pCursor) \ + ScreenPtr pScreen; \ + unsigned char *buf; \ + rfbPixelFormat *fmt; \ + CursorPtr pCursor; \ +{ \ + VNCSCREENPTR(pScreen); \ + int widthPixels, widthBytes; \ + int x, y, b; \ + CARD8 *src; \ + CARD##bpp pix[2]; \ + CARD8 bitmapByte; \ + \ + pix[0] = (CARD##bpp)RGB48_TO_PIXEL(fmt, pCursor->backRed, \ + pCursor->backGreen, \ + pCursor->backBlue); \ + pix[1] = (CARD##bpp)RGB48_TO_PIXEL(fmt, pCursor->foreRed, \ + pCursor->foreGreen, \ + pCursor->foreBlue); \ + if (!pVNC->rfbServerFormat.bigEndian != !fmt->bigEndian) { \ + pix[0] = Swap##bpp(pix[0]); \ + pix[1] = Swap##bpp(pix[1]); \ + } \ + \ + src = (CARD8 *)pCursor->bits->source; \ + widthPixels = pCursor->bits->width; \ + widthBytes = PixmapBytePad(widthPixels, 1); \ + \ + for (y = 0; y < pCursor->bits->height; y++) { \ + for (x = 0; x < widthPixels / 8; x++) { \ + bitmapByte = src[y * widthBytes + x]; \ + if (screenInfo.bitmapBitOrder == LSBFirst) { \ + bitmapByte = _reverse_byte[bitmapByte]; \ + } \ + for (b = 7; b >= 0; b--) { \ + memcpy (buf, (char *)&pix[bitmapByte >> b & 1], \ + sizeof(CARD##bpp)); \ + buf += sizeof(CARD##bpp); \ + } \ + } \ + if (widthPixels % 8) { \ + bitmapByte = src[y * widthBytes + x]; \ + if (screenInfo.bitmapBitOrder == LSBFirst) { \ + bitmapByte = _reverse_byte[bitmapByte]; \ + } \ + for (b = 7; b > 7 - widthPixels % 8; b--) { \ + memcpy (buf, (char *)&pix[bitmapByte >> b & 1], \ + sizeof(CARD##bpp)); \ + buf += sizeof(CARD##bpp); \ + } \ + } \ + } \ + \ + return (widthPixels * pCursor->bits->height * (bpp / 8)); \ +} + +DEFINE_RICH_ENCODE(16) +DEFINE_RICH_ENCODE(32) + diff -pNur xorg-server-1.4.orig/hw/vnc/cutpaste.c xorg-server-1.4/hw/vnc/cutpaste.c --- xorg-server-1.4.orig/hw/vnc/cutpaste.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/cutpaste.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,90 @@ +/* + * cutpaste.c - routines to deal with cut & paste buffers / selection. + * + * 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> +#define NEED_EVENTS +#include <X11/X.h> +#include <X11/Xproto.h> +#include "rfb.h" +#include "selection.h" +#include "input.h" +#include <X11/Xatom.h> + +extern Selection *CurrentSelections; +extern int NumCurrentSelections; + + +static Bool inSetXCutText = FALSE; + +/* + * rfbSetXCutText sets the cut buffer to be the given string. We also clear + * the primary selection. Ideally we'd like to set it to the same thing, but I + * can't work out how to do that without some kind of helper X client. + */ + +void +rfbSetXCutText(char *str, int len) +{ + int i = 0; + + inSetXCutText = TRUE; + ChangeWindowProperty(WindowTable[0], XA_CUT_BUFFER0, XA_STRING, + 8, PropModeReplace, len, + (pointer)str, TRUE); + + while ((i < NumCurrentSelections) && + CurrentSelections[i].selection != XA_PRIMARY) + i++; + + if (i < NumCurrentSelections) { + xEvent event; + + if (CurrentSelections[i].client) { + event.u.u.type = SelectionClear; + event.u.selectionClear.time = GetTimeInMillis(); + event.u.selectionClear.window = CurrentSelections[i].window; + event.u.selectionClear.atom = CurrentSelections[i].selection; + (void) TryClientEvents (CurrentSelections[i].client, &event, 1, + NoEventMask, NoEventMask /* CantBeFiltered */, + NullGrab); + } + + CurrentSelections[i].window = None; + CurrentSelections[i].pWin = NULL; + CurrentSelections[i].client = NullClient; + } + + inSetXCutText = FALSE; +} + + +void rfbGotXCutText(char *str, int len) +{ + if (!inSetXCutText) + rfbSendServerCutText(str, len); +} diff -pNur xorg-server-1.4.orig/hw/vnc/d3des.c xorg-server-1.4/hw/vnc/d3des.c --- xorg-server-1.4.orig/hw/vnc/d3des.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/d3des.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,437 @@ +/* + * This is D3DES (V5.09) by Richard Outerbridge with the double and + * triple-length support removed for use in VNC. Also the bytebit[] array + * has been reversed so that the most significant bit in each byte of the + * key is ignored, not the least significant. + * + * These changes are: + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + */ + +/* D3DES (V5.09) - + * + * A portable, public domain, version of the Data Encryption Standard. + * + * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge. + * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation + * code; Jim Gillogly & Phil Karn for the DES key schedule code; Dennis + * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau, + * for humouring me on. + * + * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge. + * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include "d3des.h" + +static void scrunch(unsigned char *, unsigned long *); +static void unscrun(unsigned long *, unsigned char *); +static void desfunc(unsigned long *, unsigned long *); +static void cookey(unsigned long *); + +static unsigned long KnL[32] = { 0L }; + +static unsigned short bytebit[8] = { + 01, 02, 04, 010, 020, 040, 0100, 0200 }; + +static unsigned long bigbyte[24] = { + 0x800000L, 0x400000L, 0x200000L, 0x100000L, + 0x80000L, 0x40000L, 0x20000L, 0x10000L, + 0x8000L, 0x4000L, 0x2000L, 0x1000L, + 0x800L, 0x400L, 0x200L, 0x100L, + 0x80L, 0x40L, 0x20L, 0x10L, + 0x8L, 0x4L, 0x2L, 0x1L }; + +/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */ + +static unsigned char pc1[56] = { + 56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, + 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, + 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, + 13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3 }; + +static unsigned char totrot[16] = { + 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 }; + +static unsigned char pc2[48] = { + 13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, + 22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1, + 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47, + 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 }; + +void deskey(key, edf) /* Thanks to James Gillogly & Phil Karn! */ +unsigned char *key; +int edf; +{ + register int i, j, l, m, n; + unsigned char pc1m[56], pcr[56]; + unsigned long kn[32]; + + for ( j = 0; j < 56; j++ ) { + l = pc1[j]; + m = l & 07; + pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0; + } + for( i = 0; i < 16; i++ ) { + if( edf == DE1 ) m = (15 - i) << 1; + else m = i << 1; + n = m + 1; + kn[m] = kn[n] = 0L; + for( j = 0; j < 28; j++ ) { + l = j + totrot[i]; + if( l < 28 ) pcr[j] = pc1m[l]; + else pcr[j] = pc1m[l - 28]; + } + for( j = 28; j < 56; j++ ) { + l = j + totrot[i]; + if( l < 56 ) pcr[j] = pc1m[l]; + else pcr[j] = pc1m[l - 28]; + } + for( j = 0; j < 24; j++ ) { + if( pcr[pc2[j]] ) kn[m] |= bigbyte[j]; + if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j]; + } + } + cookey(kn); + return; + } + +static void cookey(raw1) +register unsigned long *raw1; +{ + register unsigned long *cook, *raw0; + unsigned long dough[32]; + register int i; + + cook = dough; + for( i = 0; i < 16; i++, raw1++ ) { + raw0 = raw1++; + *cook = (*raw0 & 0x00fc0000L) << 6; + *cook |= (*raw0 & 0x00000fc0L) << 10; + *cook |= (*raw1 & 0x00fc0000L) >> 10; + *cook++ |= (*raw1 & 0x00000fc0L) >> 6; + *cook = (*raw0 & 0x0003f000L) << 12; + *cook |= (*raw0 & 0x0000003fL) << 16; + *cook |= (*raw1 & 0x0003f000L) >> 4; + *cook++ |= (*raw1 & 0x0000003fL); + } + usekey(dough); + return; + } + +void cpkey(into) +register unsigned long *into; +{ + register unsigned long *from, *endp; + + from = KnL, endp = &KnL[32]; + while( from < endp ) *into++ = *from++; + return; + } + +void usekey(from) +register unsigned long *from; +{ + register unsigned long *to, *endp; + + to = KnL, endp = &KnL[32]; + while( to < endp ) *to++ = *from++; + return; + } + +void des(inblock, outblock) +unsigned char *inblock, *outblock; +{ + unsigned long work[2]; + + scrunch(inblock, work); + desfunc(work, KnL); + unscrun(work, outblock); + return; + } + +static void scrunch(outof, into) +register unsigned char *outof; +register unsigned long *into; +{ + *into = (*outof++ & 0xffL) << 24; + *into |= (*outof++ & 0xffL) << 16; + *into |= (*outof++ & 0xffL) << 8; + *into++ |= (*outof++ & 0xffL); + *into = (*outof++ & 0xffL) << 24; + *into |= (*outof++ & 0xffL) << 16; + *into |= (*outof++ & 0xffL) << 8; + *into |= (*outof & 0xffL); + return; + } + +static void unscrun(outof, into) +register unsigned long *outof; +register unsigned char *into; +{ + *into++ = (*outof >> 24) & 0xffL; + *into++ = (*outof >> 16) & 0xffL; + *into++ = (*outof >> 8) & 0xffL; + *into++ = *outof++ & 0xffL; + *into++ = (*outof >> 24) & 0xffL; + *into++ = (*outof >> 16) & 0xffL; + *into++ = (*outof >> 8) & 0xffL; + *into = *outof & 0xffL; + return; + } + +static unsigned long SP1[64] = { + 0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L, + 0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L, + 0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L, + 0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L, + 0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L, + 0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L, + 0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L, + 0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L, + 0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L, + 0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L, + 0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L, + 0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L, + 0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L, + 0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L, + 0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L, + 0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L }; + +static unsigned long SP2[64] = { + 0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L, + 0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L, + 0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L, + 0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L, + 0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L, + 0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L, + 0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L, + 0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L, + 0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L, + 0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L, + 0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L, + 0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L, + 0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L, + 0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L, + 0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L, + 0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L }; + +static unsigned long SP3[64] = { + 0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L, + 0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L, + 0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L, + 0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L, + 0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L, + 0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L, + 0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L, + 0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L, + 0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L, + 0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L, + 0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L, + 0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L, + 0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L, + 0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L, + 0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L, + 0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L }; + +static unsigned long SP4[64] = { + 0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L, + 0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L, + 0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L, + 0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L, + 0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L, + 0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L, + 0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L, + 0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L, + 0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L, + 0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L, + 0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L, + 0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L, + 0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L, + 0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L, + 0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L, + 0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L }; + +static unsigned long SP5[64] = { + 0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L, + 0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L, + 0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L, + 0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L, + 0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L, + 0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L, + 0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L, + 0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L, + 0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L, + 0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L, + 0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L, + 0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L, + 0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L, + 0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L, + 0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L, + 0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L }; + +static unsigned long SP6[64] = { + 0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L, + 0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L, + 0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L, + 0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L, + 0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L, + 0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L, + 0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L, + 0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L, + 0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L, + 0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L, + 0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L, + 0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L, + 0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L, + 0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L, + 0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L, + 0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L }; + +static unsigned long SP7[64] = { + 0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L, + 0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L, + 0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L, + 0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L, + 0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L, + 0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L, + 0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L, + 0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L, + 0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L, + 0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L, + 0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L, + 0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L, + 0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L, + 0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L, + 0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L, + 0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L }; + +static unsigned long SP8[64] = { + 0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L, + 0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L, + 0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L, + 0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L, + 0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L, + 0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L, + 0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L, + 0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L, + 0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L, + 0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L, + 0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L, + 0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L, + 0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L, + 0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L, + 0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L, + 0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L }; + +static void desfunc(block, keys) +register unsigned long *block, *keys; +{ + register unsigned long fval, work, right, leftt; + register int round; + + leftt = block[0]; + right = block[1]; + work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL; + right ^= work; + leftt ^= (work << 4); + work = ((leftt >> 16) ^ right) & 0x0000ffffL; + right ^= work; + leftt ^= (work << 16); + work = ((right >> 2) ^ leftt) & 0x33333333L; + leftt ^= work; + right ^= (work << 2); + work = ((right >> 8) ^ leftt) & 0x00ff00ffL; + leftt ^= work; + right ^= (work << 8); + right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL; + work = (leftt ^ right) & 0xaaaaaaaaL; + leftt ^= work; + right ^= work; + leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL; + + for( round = 0; round < 8; round++ ) { + work = (right << 28) | (right >> 4); + work ^= *keys++; + fval = SP7[ work & 0x3fL]; + fval |= SP5[(work >> 8) & 0x3fL]; + fval |= SP3[(work >> 16) & 0x3fL]; + fval |= SP1[(work >> 24) & 0x3fL]; + work = right ^ *keys++; + fval |= SP8[ work & 0x3fL]; + fval |= SP6[(work >> 8) & 0x3fL]; + fval |= SP4[(work >> 16) & 0x3fL]; + fval |= SP2[(work >> 24) & 0x3fL]; + leftt ^= fval; + work = (leftt << 28) | (leftt >> 4); + work ^= *keys++; + fval = SP7[ work & 0x3fL]; + fval |= SP5[(work >> 8) & 0x3fL]; + fval |= SP3[(work >> 16) & 0x3fL]; + fval |= SP1[(work >> 24) & 0x3fL]; + work = leftt ^ *keys++; + fval |= SP8[ work & 0x3fL]; + fval |= SP6[(work >> 8) & 0x3fL]; + fval |= SP4[(work >> 16) & 0x3fL]; + fval |= SP2[(work >> 24) & 0x3fL]; + right ^= fval; + } + + right = (right << 31) | (right >> 1); + work = (leftt ^ right) & 0xaaaaaaaaL; + leftt ^= work; + right ^= work; + leftt = (leftt << 31) | (leftt >> 1); + work = ((leftt >> 8) ^ right) & 0x00ff00ffL; + right ^= work; + leftt ^= (work << 8); + work = ((leftt >> 2) ^ right) & 0x33333333L; + right ^= work; + leftt ^= (work << 2); + work = ((right >> 16) ^ leftt) & 0x0000ffffL; + leftt ^= work; + right ^= (work << 16); + work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL; + leftt ^= work; + right ^= (work << 4); + *block++ = right; + *block = leftt; + return; + } + +/* Validation sets: + * + * Single-length key, single-length plaintext - + * Key : 0123 4567 89ab cdef + * Plain : 0123 4567 89ab cde7 + * Cipher : c957 4425 6a5e d31d + * + * Double-length key, single-length plaintext - + * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 + * Plain : 0123 4567 89ab cde7 + * Cipher : 7f1d 0a77 826b 8aff + * + * Double-length key, double-length plaintext - + * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 + * Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff + * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7 + * + * Triple-length key, single-length plaintext - + * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567 + * Plain : 0123 4567 89ab cde7 + * Cipher : de0b 7c06 ae5e 0ed5 + * + * Triple-length key, double-length plaintext - + * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567 + * Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff + * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5 + * + * d3des V5.0a rwo 9208.07 18:44 Graven Imagery + **********************************************************************/ diff -pNur xorg-server-1.4.orig/hw/vnc/d3des.h xorg-server-1.4/hw/vnc/d3des.h --- xorg-server-1.4.orig/hw/vnc/d3des.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/d3des.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,51 @@ +/* + * This is D3DES (V5.09) by Richard Outerbridge with the double and + * triple-length support removed for use in VNC. + * + * These changes are: + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + */ + +/* d3des.h - + * + * Headers and defines for d3des.c + * Graven Imagery, 1992. + * + * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge + * (GEnie : OUTER; CIS : [71755,204]) + */ + +#define EN0 0 /* MODE == encrypt */ +#define DE1 1 /* MODE == decrypt */ + +extern void deskey(unsigned char *, int); +/* hexkey[8] MODE + * Sets the internal key register according to the hexadecimal + * key contained in the 8 bytes of hexkey, according to the DES, + * for encryption or decryption according to MODE. + */ + +extern void usekey(unsigned long *); +/* cookedkey[32] + * Loads the internal key register with the data in cookedkey. + */ + +extern void cpkey(unsigned long *); +/* cookedkey[32] + * Copies the contents of the internal key register into the storage + * located at &cookedkey[0]. + */ + +extern void des(unsigned char *, unsigned char *); +/* from[8] to[8] + * Encrypts/Decrypts (according to the key currently loaded in the + * internal key register) one block of eight bytes at address 'from' + * into the block at address 'to'. They can be the same. + */ + +/* d3des.h V5.09 rwo 9208.04 15:06 Graven Imagery + ********************************************************************/ diff -pNur xorg-server-1.4.orig/hw/vnc/dispcur.c xorg-server-1.4/hw/vnc/dispcur.c --- xorg-server-1.4.orig/hw/vnc/dispcur.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/dispcur.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,791 @@ +/* + * dispcur.c + * + * cursor display routines - based on midispcur.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) 1989 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 + +#define NEED_EVENTS +# include <X11/X.h> +# include "rfb.h" +# include "misc.h" +# include "input.h" +# include "cursorstr.h" +# include "windowstr.h" +# include "regionstr.h" +# include "dixstruct.h" +# include "scrnintstr.h" +# include "servermd.h" +# include "sprite.h" +# include "gcstruct.h" + +#ifdef ARGB_CURSOR +# include "picturestr.h" +#endif + +/* per-screen private data */ + +static int rfbDCScreenIndex; +static unsigned long rfbDCGeneration = 0; + +static Bool rfbDCCloseScreen(int index, ScreenPtr pScreen); + +typedef struct { + GCPtr pSourceGC, pMaskGC; + GCPtr pSaveGC, pRestoreGC; + GCPtr pMoveGC; + GCPtr pPixSourceGC, pPixMaskGC; + CloseScreenProcPtr CloseScreen; + PixmapPtr pSave, pTemp; +#ifdef ARGB_CURSOR + PicturePtr pRootPicture; + PicturePtr pTempPicture; +#endif +} rfbDCScreenRec, *rfbDCScreenPtr; + +/* per-cursor per-screen private data */ +typedef struct { + PixmapPtr sourceBits; /* source bits */ + PixmapPtr maskBits; /* mask bits */ +#ifdef ARGB_CURSOR + PicturePtr pPicture; +#endif +} rfbDCCursorRec, *rfbDCCursorPtr; + +/* + * sprite/cursor method table + */ + +static Bool rfbDCRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor); +static Bool rfbDCUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor); +static Bool rfbDCPutUpCursor(ScreenPtr pScreen, CursorPtr pCursor, + int x, int y, unsigned long source, + unsigned long mask); +static Bool rfbDCSaveUnderCursor(ScreenPtr pScreen, int x, int y, + int w, int h); +static Bool rfbDCRestoreUnderCursor(ScreenPtr pScreen, int x, int y, + int w, int h); +static Bool rfbDCMoveCursor(ScreenPtr pScreen, CursorPtr pCursor, + int x, int y, int w, int h, int dx, int dy, + unsigned long source, unsigned long mask); +static Bool rfbDCChangeSave(ScreenPtr pScreen, int x, int y, int w, int h, + int dx, int dy); + +static rfbSpriteCursorFuncRec rfbDCFuncs = { + rfbDCRealizeCursor, + rfbDCUnrealizeCursor, + rfbDCPutUpCursor, + rfbDCSaveUnderCursor, + rfbDCRestoreUnderCursor, + rfbDCMoveCursor, + rfbDCChangeSave, +}; + +Bool +rfbDCInitialize (ScreenPtr pScreen, miPointerScreenFuncPtr screenFuncs) +{ + rfbDCScreenPtr pScreenPriv; + + if (rfbDCGeneration != serverGeneration) + { + rfbDCScreenIndex = AllocateScreenPrivateIndex (); + if (rfbDCScreenIndex < 0) + return FALSE; + rfbDCGeneration = serverGeneration; + } + pScreenPriv = (rfbDCScreenPtr) xalloc (sizeof (rfbDCScreenRec)); + if (!pScreenPriv) + return FALSE; + + /* + * initialize the entire private structure to zeros + */ + + pScreenPriv->pSourceGC = + pScreenPriv->pMaskGC = + pScreenPriv->pSaveGC = + pScreenPriv->pRestoreGC = + pScreenPriv->pMoveGC = + pScreenPriv->pPixSourceGC = + pScreenPriv->pPixMaskGC = NULL; +#ifdef ARGB_CURSOR + pScreenPriv->pRootPicture = NULL; + pScreenPriv->pTempPicture = NULL; +#endif + + pScreenPriv->pSave = pScreenPriv->pTemp = NULL; + + pScreenPriv->CloseScreen = pScreen->CloseScreen; + pScreen->CloseScreen = rfbDCCloseScreen; + + pScreen->devPrivates[rfbDCScreenIndex].ptr = (pointer) pScreenPriv; + + if (!rfbSpriteInitialize (pScreen, &rfbDCFuncs, screenFuncs)) + { + xfree ((pointer) pScreenPriv); + return FALSE; + } + return TRUE; +} + +#define tossGC(gc) (gc ? FreeGC (gc, (GContext) 0) : 0) +#define tossPix(pix) (pix ? (*pScreen->DestroyPixmap) (pix) : TRUE) +#define tossPict(pict) (pict ? FreePicture (pict, 0) : 0) + +static Bool +rfbDCCloseScreen (index, pScreen) + ScreenPtr pScreen; +{ + rfbDCScreenPtr pScreenPriv; + + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pScreen->CloseScreen = pScreenPriv->CloseScreen; + tossGC (pScreenPriv->pSourceGC); + tossGC (pScreenPriv->pMaskGC); + tossGC (pScreenPriv->pSaveGC); + tossGC (pScreenPriv->pRestoreGC); + tossGC (pScreenPriv->pMoveGC); + tossGC (pScreenPriv->pPixSourceGC); + tossGC (pScreenPriv->pPixMaskGC); + tossPix (pScreenPriv->pSave); + tossPix (pScreenPriv->pTemp); +#ifdef ARGB_CURSOR + tossPict (pScreenPriv->pRootPicture); + tossPict (pScreenPriv->pTempPicture); +#endif + xfree ((pointer) pScreenPriv); + return (*pScreen->CloseScreen) (index, pScreen); +} + +static Bool +rfbDCRealizeCursor (pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + if (pCursor->bits->refcnt <= 1) + pCursor->bits->devPriv[pScreen->myNum] = (pointer)NULL; + return TRUE; +} + +#ifdef ARGB_CURSOR +#define EnsurePicture(picture,draw,win) (picture || rfbDCMakePicture(&picture,draw,win)) + +static VisualPtr +rfbDCGetWindowVisual (WindowPtr pWin) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + VisualID vid = wVisual (pWin); + int i; + + for (i = 0; i < pScreen->numVisuals; i++) + if (pScreen->visuals[i].vid == vid) + return &pScreen->visuals[i]; + return 0; +} + +static PicturePtr +rfbDCMakePicture (PicturePtr *ppPicture, DrawablePtr pDraw, WindowPtr pWin) +{ + ScreenPtr pScreen = pDraw->pScreen; + VisualPtr pVisual; + PictFormatPtr pFormat; + XID subwindow_mode = IncludeInferiors; + PicturePtr pPicture; + int error; + + pVisual = rfbDCGetWindowVisual (pWin); + if (!pVisual) + return 0; + pFormat = PictureMatchVisual (pScreen, pDraw->depth, pVisual); + if (!pFormat) + return 0; + pPicture = CreatePicture (0, pDraw, pFormat, + CPSubwindowMode, &subwindow_mode, + serverClient, &error); + *ppPicture = pPicture; + return pPicture; +} +#endif + +static rfbDCCursorPtr +rfbDCRealize (ScreenPtr pScreen, CursorPtr pCursor) +{ + rfbDCCursorPtr pPriv; + GCPtr pGC; + XID gcvals[3]; + + pPriv = (rfbDCCursorPtr) xalloc (sizeof (rfbDCCursorRec)); + if (!pPriv) + return (rfbDCCursorPtr)NULL; +#ifdef ARGB_CURSOR + if (pCursor->bits->argb) + { + PixmapPtr pPixmap; + PictFormatPtr pFormat; + int error; + + pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8); + if (!pFormat) + { + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + + pPriv->sourceBits = 0; + pPriv->maskBits = 0; + pPixmap = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, + pCursor->bits->height, 32); + if (!pPixmap) + { + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + pGC = GetScratchGC (32, pScreen); + if (!pGC) + { + (*pScreen->DestroyPixmap) (pPixmap); + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + ValidateGC (&pPixmap->drawable, pGC); + (*pGC->ops->PutImage) (&pPixmap->drawable, pGC, 32, + 0, 0, pCursor->bits->width, + pCursor->bits->height, + 0, ZPixmap, (char *) pCursor->bits->argb); + FreeScratchGC (pGC); + pPriv->pPicture = CreatePicture (0, &pPixmap->drawable, + pFormat, 0, 0, serverClient, &error); + (*pScreen->DestroyPixmap) (pPixmap); + if (!pPriv->pPicture) + { + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + pCursor->bits->devPriv[pScreen->myNum] = (pointer) pPriv; + return pPriv; + } + pPriv->pPicture = 0; +#endif + pPriv->sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1); + if (!pPriv->sourceBits) + { + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + pPriv->maskBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1); + if (!pPriv->maskBits) + { + (*pScreen->DestroyPixmap) (pPriv->sourceBits); + xfree ((pointer) pPriv); + return (rfbDCCursorPtr)NULL; + } + pCursor->bits->devPriv[pScreen->myNum] = (pointer) pPriv; + + /* create the two sets of bits, clipping as appropriate */ + + pGC = GetScratchGC (1, pScreen); + if (!pGC) + { + (void) rfbDCUnrealizeCursor (pScreen, pCursor); + return (rfbDCCursorPtr)NULL; + } + + ValidateGC ((DrawablePtr)pPriv->sourceBits, pGC); + (*pGC->ops->PutImage) ((DrawablePtr)pPriv->sourceBits, pGC, 1, + 0, 0, pCursor->bits->width, pCursor->bits->height, + 0, XYPixmap, (char *)pCursor->bits->source); + gcvals[0] = GXand; + ChangeGC (pGC, GCFunction, gcvals); + ValidateGC ((DrawablePtr)pPriv->sourceBits, pGC); + (*pGC->ops->PutImage) ((DrawablePtr)pPriv->sourceBits, pGC, 1, + 0, 0, pCursor->bits->width, pCursor->bits->height, + 0, XYPixmap, (char *)pCursor->bits->mask); + + /* mask bits -- pCursor->mask & ~pCursor->source */ + gcvals[0] = GXcopy; + ChangeGC (pGC, GCFunction, gcvals); + ValidateGC ((DrawablePtr)pPriv->maskBits, pGC); + (*pGC->ops->PutImage) ((DrawablePtr)pPriv->maskBits, pGC, 1, + 0, 0, pCursor->bits->width, pCursor->bits->height, + 0, XYPixmap, (char *)pCursor->bits->mask); + gcvals[0] = GXandInverted; + ChangeGC (pGC, GCFunction, gcvals); + ValidateGC ((DrawablePtr)pPriv->maskBits, pGC); + (*pGC->ops->PutImage) ((DrawablePtr)pPriv->maskBits, pGC, 1, + 0, 0, pCursor->bits->width, pCursor->bits->height, + 0, XYPixmap, (char *)pCursor->bits->source); + FreeScratchGC (pGC); + return pPriv; +} + +static Bool +rfbDCUnrealizeCursor (pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + rfbDCCursorPtr pPriv; + + pPriv = (rfbDCCursorPtr) pCursor->bits->devPriv[pScreen->myNum]; + if (pPriv && (pCursor->bits->refcnt <= 1)) + { + if (pPriv->sourceBits) + (*pScreen->DestroyPixmap) (pPriv->sourceBits); + if (pPriv->maskBits) + (*pScreen->DestroyPixmap) (pPriv->maskBits); +#ifdef ARGB_CURSOR + if (pPriv->pPicture) + FreePicture (pPriv->pPicture, 0); +#endif + xfree ((pointer) pPriv); + pCursor->bits->devPriv[pScreen->myNum] = (pointer)NULL; + } + return TRUE; +} + +static void +rfbDCPutBits (DrawablePtr pDrawable, rfbDCCursorPtr pPriv, GCPtr sourceGC, GCPtr maskGC, int x, int y, unsigned w, unsigned h, unsigned long source, unsigned long mask) +{ + XID gcvals[1]; + + if (sourceGC->fgPixel != source) + { + gcvals[0] = source; + DoChangeGC (sourceGC, GCForeground, gcvals, 0); + } + if (sourceGC->serialNumber != pDrawable->serialNumber) + ValidateGC (pDrawable, sourceGC); + (*sourceGC->ops->PushPixels) (sourceGC, pPriv->sourceBits, pDrawable, w, h, x, y); + if (maskGC->fgPixel != mask) + { + gcvals[0] = mask; + DoChangeGC (maskGC, GCForeground, gcvals, 0); + } + if (maskGC->serialNumber != pDrawable->serialNumber) + ValidateGC (pDrawable, maskGC); + (*maskGC->ops->PushPixels) (maskGC, pPriv->maskBits, pDrawable, w, h, x, y); +} + +#define EnsureGC(gc,win) (gc || rfbDCMakeGC(&gc, win)) + +static GCPtr +rfbDCMakeGC(GCPtr *ppGC, WindowPtr pWin) +{ + GCPtr pGC; + int status; + XID gcvals[2]; + + gcvals[0] = IncludeInferiors; + gcvals[1] = FALSE; + pGC = CreateGC((DrawablePtr)pWin, + GCSubwindowMode|GCGraphicsExposures, gcvals, &status); + if (pGC && pWin->drawable.pScreen->DrawGuarantee) + (*pWin->drawable.pScreen->DrawGuarantee) (pWin, pGC, GuaranteeVisBack); + *ppGC = pGC; + return pGC; +} + +static Bool +rfbDCPutUpCursor (pScreen, pCursor, x, y, source, mask) + ScreenPtr pScreen; + CursorPtr pCursor; + int x, y; + unsigned long source, mask; +{ + rfbDCScreenPtr pScreenPriv; + rfbDCCursorPtr pPriv; + WindowPtr pWin; + + pPriv = (rfbDCCursorPtr) pCursor->bits->devPriv[pScreen->myNum]; + if (!pPriv) + { + pPriv = rfbDCRealize(pScreen, pCursor); + if (!pPriv) + return FALSE; + } + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pWin = WindowTable[pScreen->myNum]; +#ifdef ARGB_CURSOR + if (pPriv->pPicture) + { + if (!EnsurePicture(pScreenPriv->pRootPicture, &pWin->drawable, pWin)) + return FALSE; + CompositePicture (PictOpOver, + pPriv->pPicture, + NULL, + pScreenPriv->pRootPicture, + 0, 0, 0, 0, + x, y, + pCursor->bits->width, + pCursor->bits->height); + } + else +#endif + { + if (!EnsureGC(pScreenPriv->pSourceGC, pWin)) + return FALSE; + if (!EnsureGC(pScreenPriv->pMaskGC, pWin)) + { + FreeGC (pScreenPriv->pSourceGC, (GContext) 0); + pScreenPriv->pSourceGC = 0; + return FALSE; + } + rfbDCPutBits ((DrawablePtr)pWin, pPriv, + pScreenPriv->pSourceGC, pScreenPriv->pMaskGC, + x, y, pCursor->bits->width, pCursor->bits->height, + source, mask); + } + return TRUE; +} + +static Bool +rfbDCSaveUnderCursor (pScreen, x, y, w, h) + ScreenPtr pScreen; + int x, y, w, h; +{ + rfbDCScreenPtr pScreenPriv; + PixmapPtr pSave; + WindowPtr pWin; + GCPtr pGC; + + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pSave = pScreenPriv->pSave; + pWin = WindowTable[pScreen->myNum]; + if (!pSave || pSave->drawable.width < w || pSave->drawable.height < h) + { + if (pSave) + (*pScreen->DestroyPixmap) (pSave); + pScreenPriv->pSave = pSave = + (*pScreen->CreatePixmap) (pScreen, w, h, pScreen->rootDepth); + if (!pSave) + return FALSE; + } + if (!EnsureGC(pScreenPriv->pSaveGC, pWin)) + return FALSE; + pGC = pScreenPriv->pSaveGC; + if (pSave->drawable.serialNumber != pGC->serialNumber) + ValidateGC ((DrawablePtr) pSave, pGC); + (*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC, + x, y, w, h, 0, 0); + return TRUE; +} + +static Bool +rfbDCRestoreUnderCursor (pScreen, x, y, w, h) + ScreenPtr pScreen; + int x, y, w, h; +{ + rfbDCScreenPtr pScreenPriv; + PixmapPtr pSave; + WindowPtr pWin; + GCPtr pGC; + + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pSave = pScreenPriv->pSave; + pWin = WindowTable[pScreen->myNum]; + if (!pSave) + return FALSE; + if (!EnsureGC(pScreenPriv->pRestoreGC, pWin)) + return FALSE; + pGC = pScreenPriv->pRestoreGC; + if (pWin->drawable.serialNumber != pGC->serialNumber) + ValidateGC ((DrawablePtr) pWin, pGC); + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC, + 0, 0, w, h, x, y); + return TRUE; +} + +static Bool +rfbDCChangeSave (pScreen, x, y, w, h, dx, dy) + ScreenPtr pScreen; + int x, y, w, h, dx, dy; +{ + rfbDCScreenPtr pScreenPriv; + PixmapPtr pSave; + WindowPtr pWin; + GCPtr pGC; + int sourcex, sourcey, destx, desty, copyw, copyh; + + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pSave = pScreenPriv->pSave; + pWin = WindowTable[pScreen->myNum]; + /* + * restore the bits which are about to get trashed + */ + if (!pSave) + return FALSE; + if (!EnsureGC(pScreenPriv->pRestoreGC, pWin)) + return FALSE; + pGC = pScreenPriv->pRestoreGC; + if (pWin->drawable.serialNumber != pGC->serialNumber) + ValidateGC ((DrawablePtr) pWin, pGC); + /* + * copy the old bits to the screen. + */ + if (dy > 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC, + 0, h - dy, w, dy, x + dx, y + h); + } + else if (dy < 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC, + 0, 0, w, -dy, x + dx, y + dy); + } + if (dy >= 0) + { + desty = y + dy; + sourcey = 0; + copyh = h - dy; + } + else + { + desty = y; + sourcey = - dy; + copyh = h + dy; + } + if (dx > 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC, + w - dx, sourcey, dx, copyh, x + w, desty); + } + else if (dx < 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC, + 0, sourcey, -dx, copyh, x + dx, desty); + } + if (!EnsureGC(pScreenPriv->pSaveGC, pWin)) + return FALSE; + pGC = pScreenPriv->pSaveGC; + if (pSave->drawable.serialNumber != pGC->serialNumber) + ValidateGC ((DrawablePtr) pSave, pGC); + /* + * move the bits that are still valid within the pixmap + */ + if (dx >= 0) + { + sourcex = 0; + destx = dx; + copyw = w - dx; + } + else + { + destx = 0; + sourcex = - dx; + copyw = w + dx; + } + if (dy >= 0) + { + sourcey = 0; + desty = dy; + copyh = h - dy; + } + else + { + desty = 0; + sourcey = -dy; + copyh = h + dy; + } + (*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pSave, pGC, + sourcex, sourcey, copyw, copyh, destx, desty); + /* + * copy the new bits from the screen into the remaining areas of the + * pixmap + */ + if (dy > 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC, + x, y, w, dy, 0, 0); + } + else if (dy < 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC, + x, y + h + dy, w, -dy, 0, h + dy); + } + if (dy >= 0) + { + desty = dy; + sourcey = y + dy; + copyh = h - dy; + } + else + { + desty = 0; + sourcey = y; + copyh = h + dy; + } + if (dx > 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC, + x, sourcey, dx, copyh, 0, desty); + } + else if (dx < 0) + { + (*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC, + x + w + dx, sourcey, -dx, copyh, w + dx, desty); + } + return TRUE; +} + +static Bool +rfbDCMoveCursor (pScreen, pCursor, x, y, w, h, dx, dy, source, mask) + ScreenPtr pScreen; + CursorPtr pCursor; + int x, y, w, h, dx, dy; + unsigned long source, mask; +{ + rfbDCCursorPtr pPriv; + rfbDCScreenPtr pScreenPriv; + int status; + WindowPtr pWin; + GCPtr pGC; + XID gcval = FALSE; + PixmapPtr pTemp; + + pPriv = (rfbDCCursorPtr) pCursor->bits->devPriv[pScreen->myNum]; + if (!pPriv) + { + pPriv = rfbDCRealize(pScreen, pCursor); + if (!pPriv) + return FALSE; + } + pScreenPriv = (rfbDCScreenPtr) pScreen->devPrivates[rfbDCScreenIndex].ptr; + pWin = WindowTable[pScreen->myNum]; + pTemp = pScreenPriv->pTemp; + if (!pTemp || + pTemp->drawable.width != pScreenPriv->pSave->drawable.width || + pTemp->drawable.height != pScreenPriv->pSave->drawable.height) + { + if (pTemp) + (*pScreen->DestroyPixmap) (pTemp); +#ifdef ARGB_CURSOR + if (pScreenPriv->pTempPicture) + { + FreePicture (pScreenPriv->pTempPicture, 0); + pScreenPriv->pTempPicture = 0; + } +#endif + pScreenPriv->pTemp = pTemp = (*pScreen->CreatePixmap) + (pScreen, w, h, pScreenPriv->pSave->drawable.depth); + if (!pTemp) + return FALSE; + } + if (!pScreenPriv->pMoveGC) + { + pScreenPriv->pMoveGC = CreateGC ((DrawablePtr)pTemp, + GCGraphicsExposures, &gcval, &status); + if (!pScreenPriv->pMoveGC) + return FALSE; + } + /* + * copy the saved area to a temporary pixmap + */ + pGC = pScreenPriv->pMoveGC; + if (pGC->serialNumber != pTemp->drawable.serialNumber) + ValidateGC ((DrawablePtr) pTemp, pGC); + (*pGC->ops->CopyArea)((DrawablePtr)pScreenPriv->pSave, + (DrawablePtr)pTemp, pGC, 0, 0, w, h, 0, 0); + + /* + * draw the cursor in the temporary pixmap + */ +#ifdef ARGB_CURSOR + if (pPriv->pPicture) + { + if (!EnsurePicture(pScreenPriv->pTempPicture, &pTemp->drawable, pWin)) + return FALSE; + CompositePicture (PictOpOver, + pPriv->pPicture, + NULL, + pScreenPriv->pTempPicture, + 0, 0, 0, 0, + dx, dy, + pCursor->bits->width, + pCursor->bits->height); + } + else +#endif + { + if (!pScreenPriv->pPixSourceGC) + { + pScreenPriv->pPixSourceGC = CreateGC ((DrawablePtr)pTemp, + GCGraphicsExposures, &gcval, &status); + if (!pScreenPriv->pPixSourceGC) + return FALSE; + } + if (!pScreenPriv->pPixMaskGC) + { + pScreenPriv->pPixMaskGC = CreateGC ((DrawablePtr)pTemp, + GCGraphicsExposures, &gcval, &status); + if (!pScreenPriv->pPixMaskGC) + return FALSE; + } + rfbDCPutBits ((DrawablePtr)pTemp, pPriv, + pScreenPriv->pPixSourceGC, pScreenPriv->pPixMaskGC, + dx, dy, pCursor->bits->width, pCursor->bits->height, + source, mask); + } + + /* + * copy the temporary pixmap onto the screen + */ + + if (!EnsureGC(pScreenPriv->pRestoreGC, pWin)) + return FALSE; + pGC = pScreenPriv->pRestoreGC; + if (pWin->drawable.serialNumber != pGC->serialNumber) + ValidateGC ((DrawablePtr) pWin, pGC); + + (*pGC->ops->CopyArea) ((DrawablePtr) pTemp, (DrawablePtr) pWin, + pGC, + 0, 0, w, h, x, y); + return TRUE; +} diff -pNur xorg-server-1.4.orig/hw/vnc/dpmsstubs.c xorg-server-1.4/hw/vnc/dpmsstubs.c --- xorg-server-1.4.orig/hw/vnc/dpmsstubs.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/dpmsstubs.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,52 @@ +/* $Xorg: dpmsstubs.c,v 1.3 2000/08/17 19:47:56 cpqbld Exp $ */ +/***************************************************************** + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +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. + +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 +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL 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 Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + +******************************************************************/ +/* $XFree86: xc/programs/Xserver/Xext/dpmsstubs.c,v 3.3 1999/12/16 02:26:23 robin Exp $ */ + +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include "rfb.h" + +#define FALSE 0 + +Bool DPMSSupported(void) +{ + return FALSE; +} + +int DPSMGet(int *level) +{ + return -1; +} + +void DPMSSet(int level) +{ + +} diff -pNur xorg-server-1.4.orig/hw/vnc/draw.c xorg-server-1.4/hw/vnc/draw.c --- xorg-server-1.4.orig/hw/vnc/draw.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/draw.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,2020 @@ +/* + * draw.c - drawing routines for the RFB X server. This is a set of + * wrappers around the standard MI/MFB/CFB drawing routines which work out + * to a fair approximation the region of the screen being modified by the + * drawing. If the RFB client is ready then the modified region of the screen + * is sent to the client, otherwise the modified region will simply grow with + * each drawing request until the client is ready. + * + * 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) 1989 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 rfbDeferUpdateTime = 40; /* ms */ + + +/****************************************************************************/ +/* + * Macro definitions + */ +/****************************************************************************/ + +#define TRC(x) /* (rfbLog x) */ + +/* ADD_TO_MODIFIED_REGION adds the given region to the modified region for each + client */ + +#define ADD_TO_MODIFIED_REGION(pScreen,reg) \ + { \ + rfbClientPtr cl; \ + for (cl = rfbClientHead; cl; cl = cl->next) { \ + REGION_UNION((pScreen),&cl->modifiedRegion,&cl->modifiedRegion,reg);\ + } \ + } + +/* SCHEDULE_FB_UPDATE is used at the end of each drawing routine to schedule an + update to be sent to each client if there is one pending and the client is + ready for it. */ + +#define SCHEDULE_FB_UPDATE(pScreen,pVNC) \ + if (!pVNC->dontSendFramebufferUpdate) { \ + rfbClientPtr cl, nextCl; \ + for (cl = rfbClientHead; cl; cl = nextCl) { \ + nextCl = cl->next; \ + if (!cl->deferredUpdateScheduled && FB_UPDATE_PENDING(cl) && \ + REGION_NOTEMPTY(pScreen,&cl->requestedRegion)) \ + { \ + rfbScheduleDeferredUpdate(pScreen, cl); \ + } \ + } \ + } + +/* function prototypes */ + +static void rfbScheduleDeferredUpdate(ScreenPtr pScreen, rfbClientPtr cl); +static void rfbCopyRegion(ScreenPtr pScreen, rfbClientPtr cl, + RegionPtr src, RegionPtr dst, int dx, int dy); +#ifdef DEBUG +static void PrintRegion(ScreenPtr pScreen, RegionPtr reg); +#endif + +/* GC funcs */ + +static void rfbValidateGC(GCPtr, unsigned long /*changes*/, DrawablePtr); +static void rfbChangeGC(GCPtr, unsigned long /*mask*/); +static void rfbCopyGC(GCPtr /*src*/, unsigned long /*mask*/, GCPtr /*dst*/); +static void rfbDestroyGC(GCPtr); +static void rfbChangeClip(GCPtr, int /*type*/, pointer /*pValue*/, + int /*nrects*/); +static void rfbDestroyClip(GCPtr); +static void rfbCopyClip(GCPtr /*dst*/, GCPtr /*src*/); + +/* GC ops */ + +static void rfbFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nInit, DDXPointPtr pptInit, int *pwidthInit, int fSorted); +static void rfbSetSpans(DrawablePtr pDrawable, + GCPtr pGC, + char *psrc, + register DDXPointPtr ppt, + int *pwidth, + int nspans, + int fSorted); +static void rfbPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y, int w, int h, int leftPad, int format, char *pBits); +static RegionPtr rfbCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy, int w, int h, int dstx, int dsty); +static RegionPtr rfbCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, register GCPtr pGC, int srcx, int srcy, int w, int h, int dstx, int dsty, unsigned long plane); +static void rfbPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, xPoint *pts); +static void rfbPolylines (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr ppts); +static void rfbPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *segs); +static void rfbPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nrects, xRectangle *rects); +static void rfbPolyArc(DrawablePtr pDrawable, register GCPtr pGC, int narcs, xArc *arcs); +static void rfbFillPolygon(register DrawablePtr pDrawable, register GCPtr pGC, int shape, int mode, int count, DDXPointPtr pts); +static void rfbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrects, xRectangle *rects); +static void rfbPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *arcs); +static int rfbPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars); +static int rfbPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars); +static void rfbImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars); +static void rfbImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars); +static void rfbImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); +static void rfbPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); +static void rfbPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable, int w, int h, int x, int y); + + +static GCFuncs rfbGCFuncs = { + rfbValidateGC, + rfbChangeGC, + rfbCopyGC, + rfbDestroyGC, + rfbChangeClip, + rfbDestroyClip, + rfbCopyClip, +}; + + +static GCOps rfbGCOps = { + rfbFillSpans, rfbSetSpans, rfbPutImage, + rfbCopyArea, rfbCopyPlane, rfbPolyPoint, + rfbPolylines, rfbPolySegment, rfbPolyRectangle, + rfbPolyArc, rfbFillPolygon, rfbPolyFillRect, + rfbPolyFillArc, rfbPolyText8, rfbPolyText16, + rfbImageText8, rfbImageText16, rfbImageGlyphBlt, + rfbPolyGlyphBlt, rfbPushPixels +}; + + + +/****************************************************************************/ +/* + * Screen functions wrapper stuff + */ +/****************************************************************************/ + +#define SCREEN_PROLOGUE(scrn, field) \ + ScreenPtr pScreen = scrn; \ + VNCSCREENPTR(pScreen); \ + pScreen->field = pVNC->field; + +#define SCREEN_EPILOGUE(field, wrapper) \ + pScreen->field = wrapper; + + +/* + * CloseScreen wrapper -- unwrap everything, free the private data + * and call the wrapped CloseScreen function. + */ + +Bool +rfbCloseScreen (int i, ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); +#if XFREE86VNC + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; +#endif + int sock; + + for (sock = 0; sock <= pVNC->maxFd; sock++) { + if (FD_ISSET(sock, &pVNC->allFds)) + if (sock != pVNC->rfbListenSock && sock != pVNC->httpListenSock) { + rfbCloseSock(pScreen, sock); + } + } + + if (pVNC->rfbListenSock > 0) + if (close(pVNC->rfbListenSock)) + ErrorF("Close of port %d failed\n",pVNC->rfbPort); + + if (pVNC->httpListenSock > 0) + if (close(pVNC->httpListenSock)) + ErrorF("Close of port %d failed\n",pVNC->httpPort); + + pScreen->CloseScreen = pVNC->CloseScreen; + pScreen->CreateGC = pVNC->CreateGC; + pScreen->PaintWindowBackground = pVNC->PaintWindowBackground; + pScreen->PaintWindowBorder = pVNC->PaintWindowBorder; + pScreen->CopyWindow = pVNC->CopyWindow; + pScreen->ClearToBackground = pVNC->ClearToBackground; + pScreen->RestoreAreas = pVNC->RestoreAreas; + pScreen->WakeupHandler = pVNC->WakeupHandler; + +#if XFREE86VNC + pScreen->InstallColormap = pVNC->InstallColormap; + pScreen->UninstallColormap = pVNC->UninstallColormap; + pScreen->ListInstalledColormaps = pVNC->ListInstalledColormaps; + pScreen->StoreColors = pVNC->StoreColors; + pScrn->EnableDisableFBAccess = pVNC->EnableDisableFBAccess; + + xfree(pVNC); +#endif + + TRC((stderr,"Unwrapped screen functions\n")); + + return (*pScreen->CloseScreen) (i, pScreen); +} + +#if XFREE86VNC +void +rfbEnableDisableFBAccess (int index, Bool enable) +{ + ScrnInfoPtr pScrn = xf86Screens[index]; + VNCSCREENPTR(pScrn->pScreen); + + /* + * Blank the screen for security while inputs are disabled. + * When VT switching is fixed, we might be able to allow + * control even when switched away. + */ + if (!enable) { + WindowPtr pWin = WindowTable[index]; + ScreenPtr pScreen = pWin->drawable.pScreen; + GCPtr pGC; + xRectangle rect; + + rect.x = 0; + rect.y = 0; + rect.width = pScrn->virtualX; + rect.height = pScrn->virtualY; + + if (!(pGC = GetScratchGC(pScreen->rootDepth, pScreen))) { + ErrorF("Couldn't blank screen"); + } else { + CARD32 attributes[2]; + attributes[0] = pScreen->whitePixel; + attributes[1] = pScreen->blackPixel; + (void)ChangeGC(pGC, GCForeground | GCBackground, attributes); + + ValidateGC((DrawablePtr)pWin, pGC); + + (*pGC->ops->PolyFillRect)((DrawablePtr)pWin, pGC, 1, &rect); + + FreeScratchGC(pGC); + + /* Flush pending packets */ + rfbCheckFds(pScreen); + httpCheckFds(pScreen); + } + } + + pScrn->EnableDisableFBAccess = pVNC->EnableDisableFBAccess; + (*pScrn->EnableDisableFBAccess)(index, enable); + pScrn->EnableDisableFBAccess = rfbEnableDisableFBAccess; +} +#endif + +/* + * CreateGC - wrap the GC funcs (the GC ops will be wrapped when the GC + * func "ValidateGC" is called). + */ + +Bool +rfbCreateGC (GCPtr pGC) +{ + Bool ret; + rfbGCPtr pGCPriv; + + SCREEN_PROLOGUE(pGC->pScreen,CreateGC); + + pGCPriv = (rfbGCPtr)pGC->devPrivates[rfbGCIndex].ptr; + + ret = (*pScreen->CreateGC) (pGC); + + TRC((stderr,"rfbCreateGC called\n")); + + pGCPriv->wrapOps = NULL; + pGCPriv->wrapFuncs = pGC->funcs; + pGC->funcs = &rfbGCFuncs; + + SCREEN_EPILOGUE(CreateGC,rfbCreateGC); + + return ret; +} + +/* + * PaintWindowBackground - the region being modified is just the given region. + */ + +void +rfbPaintWindowBackground (WindowPtr pWin, RegionPtr pRegion, int what) +{ + SCREEN_PROLOGUE(pWin->drawable.pScreen,PaintWindowBackground); + + TRC((stderr,"rfbPaintWindowBackground called\n")); + + ADD_TO_MODIFIED_REGION(pScreen,pRegion); + + (*pScreen->PaintWindowBackground) (pWin, pRegion, what); + + SCHEDULE_FB_UPDATE(pScreen, pVNC); + + SCREEN_EPILOGUE(PaintWindowBackground,rfbPaintWindowBackground); +} + +/* + * PaintWindowBorder - the region being modified is just the given region. + */ + +void +rfbPaintWindowBorder (WindowPtr pWin, RegionPtr pRegion, int what) +{ + SCREEN_PROLOGUE(pWin->drawable.pScreen,PaintWindowBorder); + + TRC((stderr,"rfbPaintWindowBorder called\n")); + + ADD_TO_MODIFIED_REGION(pScreen,pRegion); + + (*pScreen->PaintWindowBorder) (pWin, pRegion, what); + + SCHEDULE_FB_UPDATE(pScreen, pVNC); + + SCREEN_EPILOGUE(PaintWindowBorder,rfbPaintWindowBorder); +} + +#ifdef CHROMIUM +Bool +rfbRealizeWindow(WindowPtr pWin) +{ + CRWindowTable *wt = NULL, *nextWt = NULL; + Bool ret; + SCREEN_PROLOGUE(pWin->drawable.pScreen,RealizeWindow); + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + rfbSendChromiumWindowShow(wt->CRwinId, 1); + } + } + + ret = (*pScreen->RealizeWindow)(pWin); + + SCREEN_EPILOGUE(RealizeWindow,rfbRealizeWindow); + + return ret; +} + +Bool +rfbUnrealizeWindow(WindowPtr pWin) +{ + CRWindowTable *wt = NULL, *nextWt = NULL; + Bool ret; + SCREEN_PROLOGUE(pWin->drawable.pScreen,UnrealizeWindow); + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + rfbSendChromiumWindowShow(wt->CRwinId, 0); + } + } + + ret = (*pScreen->UnrealizeWindow)(pWin); + + SCREEN_EPILOGUE(UnrealizeWindow,rfbUnrealizeWindow); + + return ret; +} + +Bool +rfbDestroyWindow(WindowPtr pWin) +{ + CRWindowTable *wt = NULL, *nextWt = NULL, *prevWt = NULL; + Bool ret; + SCREEN_PROLOGUE(pWin->drawable.pScreen,DestroyWindow); + + /* loop over monitored windows */ + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + rfbSendChromiumWindowDestroy(wt->CRwinId); + /* also remove from list */ + if (prevWt) + prevWt->next = wt->next; + else + windowTable = wt->next; + xfree(wt); + } + else { + prevWt = wt; + } + } + + ret = (*pScreen->DestroyWindow)(pWin); + + SCREEN_EPILOGUE(DestroyWindow,rfbDestroyWindow); + + return ret; +} + +void +rfbResizeWindow(WindowPtr pWin, int x, int y, unsigned int w, unsigned int h, WindowPtr pSib) +{ + CRWindowTable *wt = NULL, *nextWt = NULL; + SCREEN_PROLOGUE(pWin->drawable.pScreen,ResizeWindow); + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + rfbSendChromiumMoveResizeWindow(wt->CRwinId, pWin->drawable.x, pWin->drawable.y, w, h); + } + } + + (*pScreen->ResizeWindow)(pWin, x, y, w, h, pSib); + + SCREEN_EPILOGUE(ResizeWindow,rfbResizeWindow); +} + +Bool +rfbPositionWindow(WindowPtr pWin, int x, int y) +{ + Bool ret; + CRWindowTable *wt, *nextWt; + SCREEN_PROLOGUE(pWin->drawable.pScreen,PositionWindow); + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + rfbSendChromiumMoveResizeWindow(wt->CRwinId, x, y, pWin->drawable.width, pWin->drawable.height); + } + } + + ret = (*pScreen->PositionWindow)(pWin, x, y); + + SCREEN_EPILOGUE(PositionWindow,rfbPositionWindow); + + return ret; +} + +void +rfbClipNotify(WindowPtr pWin, int x, int y) +{ + CRWindowTable *wt, *nextWt; + SCREEN_PROLOGUE(pWin->drawable.pScreen,ClipNotify); + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == pWin->drawable.id) { + int numClipRects = REGION_NUM_RECTS(&pWin->clipList); + BoxPtr pClipRects = REGION_RECTS(&pWin->clipList); + + /* Possible optimization - has the cliplist really? changed */ + + rfbSendChromiumClipList(wt->CRwinId, pClipRects, numClipRects); + } + } + + if (*pScreen->ClipNotify) + (*pScreen->ClipNotify)(pWin, x, y); + + SCREEN_EPILOGUE(ClipNotify,rfbClipNotify); +} +#endif /* CHROMIUM */ + +/* + * CopyWindow - the region being modified is the translation of the old + * region, clipped to the border clip region of the window. Note that any + * parts of the window which have become newly-visible will not be affected by + * this call - a separate PaintWindowBackground/Border will be called to do + * that. If the client will accept CopyRect messages then use rfbCopyRegion to + * optimise the pending screen changes into a single "copy region" plus the + * ordinary modified region. + */ + +void +rfbCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr pOldRegion) +{ + rfbClientPtr cl; + RegionRec srcRegion, dstRegion; + SCREEN_PROLOGUE(pWin->drawable.pScreen,CopyWindow); + + TRC((stderr,"rfbCopyWindow called\n")); + + REGION_NULL(pScreen,&dstRegion); + REGION_COPY(pScreen,&dstRegion,pOldRegion); + REGION_TRANSLATE(pWin->drawable.pScreen, &dstRegion, + pWin->drawable.x - ptOldOrg.x, + pWin->drawable.y - ptOldOrg.y); + REGION_INTERSECT(pWin->drawable.pScreen, &dstRegion, &dstRegion, + &pWin->borderClip); + + for (cl = rfbClientHead; cl; cl = cl->next) { + if (cl->useCopyRect) { + REGION_NULL(pScreen,&srcRegion); + REGION_COPY(pScreen,&srcRegion,pOldRegion); + + rfbCopyRegion(pScreen, cl, &srcRegion, &dstRegion, + pWin->drawable.x - ptOldOrg.x, + pWin->drawable.y - ptOldOrg.y); + + REGION_UNINIT(pScreen, &srcRegion); + + } else { + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &dstRegion); + } + } + + REGION_UNINIT(pScreen, &dstRegion); + + (*pScreen->CopyWindow) (pWin, ptOldOrg, pOldRegion); + + SCHEDULE_FB_UPDATE(pScreen, pVNC); + + SCREEN_EPILOGUE(CopyWindow,rfbCopyWindow); +} + +/* + * ClearToBackground - when generateExposures is false, the region being + * modified is the given rectangle (clipped to the "window clip region"). + */ + +void +rfbClearToBackground (WindowPtr pWin, int x, int y, int w, int h, + Bool generateExposures) +{ + RegionRec tmpRegion; + BoxRec box; + SCREEN_PROLOGUE(pWin->drawable.pScreen,ClearToBackground); + + TRC((stderr,"rfbClearToBackground called\n")); + + if (!generateExposures) { + box.x1 = x + pWin->drawable.x; + box.y1 = y + pWin->drawable.y; + box.x2 = w ? (box.x1 + w) : (pWin->drawable.x + pWin->drawable.width); + box.y2 = h ? (box.y1 + h) : (pWin->drawable.y + pWin->drawable.height); + + SAFE_REGION_INIT(pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pScreen, &tmpRegion, &tmpRegion, &pWin->clipList); + + ADD_TO_MODIFIED_REGION(pScreen, &tmpRegion); + + REGION_UNINIT(pScreen, &tmpRegion); + } + + (*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures); + + if (!generateExposures) { + SCHEDULE_FB_UPDATE(pScreen, pVNC); + } + + SCREEN_EPILOGUE(ClearToBackground,rfbClearToBackground); +} + +/* + * RestoreAreas - just be safe here - the region being modified is the whole + * exposed region. + */ + +RegionPtr +rfbRestoreAreas (WindowPtr pWin, RegionPtr prgnExposed) +{ + RegionPtr result; + SCREEN_PROLOGUE(pWin->drawable.pScreen,RestoreAreas); + + TRC((stderr,"rfbRestoreAreas called\n")); + + ADD_TO_MODIFIED_REGION(pScreen, prgnExposed); + + result = (*pScreen->RestoreAreas) (pWin, prgnExposed); + + SCHEDULE_FB_UPDATE(pScreen, pVNC); + + SCREEN_EPILOGUE(RestoreAreas,rfbRestoreAreas); + + return result; +} + + + +/****************************************************************************/ +/* + * GC funcs wrapper stuff + * + * We only really want to wrap the GC ops, but to do this we need to wrap + * ValidateGC and so all the other GC funcs must be wrapped as well. + */ +/****************************************************************************/ + +#define GC_FUNC_PROLOGUE(pGC) \ + rfbGCPtr pGCPriv = (rfbGCPtr) (pGC)->devPrivates[rfbGCIndex].ptr; \ + (pGC)->funcs = pGCPriv->wrapFuncs; \ + if (pGCPriv->wrapOps) \ + (pGC)->ops = pGCPriv->wrapOps; + +#define GC_FUNC_EPILOGUE(pGC) \ + pGCPriv->wrapFuncs = (pGC)->funcs; \ + (pGC)->funcs = &rfbGCFuncs; \ + if (pGCPriv->wrapOps) { \ + pGCPriv->wrapOps = (pGC)->ops; \ + (pGC)->ops = &rfbGCOps; \ + } + + +/* + * ValidateGC - call the wrapped ValidateGC, then wrap the resulting GC ops if + * the drawing will be to a viewable window. + */ + +static void +rfbValidateGC (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) +{ + GC_FUNC_PROLOGUE(pGC); + + TRC((stderr,"rfbValidateGC called\n")); + + (*pGC->funcs->ValidateGC) (pGC, changes, pDrawable); + + pGCPriv->wrapOps = NULL; + if (pDrawable->type == DRAWABLE_WINDOW && ((WindowPtr)pDrawable)->viewable) + { + WindowPtr pWin = (WindowPtr) pDrawable; + RegionPtr pRegion = &pWin->clipList; + + if (pGC->subWindowMode == IncludeInferiors) + pRegion = &pWin->borderClip; + if (REGION_NOTEMPTY(pDrawable->pScreen, pRegion)) { + pGCPriv->wrapOps = pGC->ops; + TRC((stderr,"rfbValidateGC: wrapped GC ops\n")); + } + } + + GC_FUNC_EPILOGUE(pGC); +} + +/* + * All other GC funcs simply unwrap the GC funcs and ops, call the wrapped + * function and then rewrap the funcs and ops. + */ + +static void +rfbChangeGC (pGC, mask) + GCPtr pGC; + unsigned long mask; +{ + GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->ChangeGC) (pGC, mask); + GC_FUNC_EPILOGUE(pGC); +} + +static void +rfbCopyGC (pGCSrc, mask, pGCDst) + GCPtr pGCSrc, pGCDst; + unsigned long mask; +{ + GC_FUNC_PROLOGUE(pGCDst); + (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst); + GC_FUNC_EPILOGUE(pGCDst); +} + +static void +rfbDestroyGC (pGC) + GCPtr pGC; +{ + GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->DestroyGC) (pGC); + GC_FUNC_EPILOGUE(pGC); +} + +static void +rfbChangeClip (pGC, type, pvalue, nrects) + GCPtr pGC; + int type; + pointer pvalue; + int nrects; +{ + GC_FUNC_PROLOGUE(pGC); + (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects); + GC_FUNC_EPILOGUE(pGC); +} + +static void +rfbDestroyClip(pGC) + GCPtr pGC; +{ + GC_FUNC_PROLOGUE(pGC); + (* pGC->funcs->DestroyClip)(pGC); + GC_FUNC_EPILOGUE(pGC); +} + +static void +rfbCopyClip(pgcDst, pgcSrc) + GCPtr pgcDst, pgcSrc; +{ + GC_FUNC_PROLOGUE(pgcDst); + (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc); + GC_FUNC_EPILOGUE(pgcDst); +} + + +/****************************************************************************/ +/* + * GC ops wrapper stuff + * + * Note that these routines will only have been wrapped for drawing to + * viewable windows so we don't need to check each time that the drawable + * is a viewable window. + */ +/****************************************************************************/ + +#define GC_OP_PROLOGUE(pDrawable,pGC) \ + ScreenPtr pScreen = pGC->pScreen; \ + VNCSCREENPTR(pScreen); \ + rfbGCPtr pGCPrivate = (rfbGCPtr) (pGC)->devPrivates[rfbGCIndex].ptr; \ + GCFuncs *oldFuncs = pGC->funcs; \ + (void) pScreen; /* silence compiler */ \ + (pGC)->funcs = pGCPrivate->wrapFuncs; \ + (pGC)->ops = pGCPrivate->wrapOps; + +#define GC_OP_EPILOGUE(pGC) \ + pGCPrivate->wrapOps = (pGC)->ops; \ + (pGC)->funcs = oldFuncs; \ + (pGC)->ops = &rfbGCOps; + + +/* + * FillSpans - being very safe - the region being modified is the border clip + * region of the window. + */ + +static void +rfbFillSpans(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) + DrawablePtr pDrawable; + GCPtr pGC; + int nInit; /* number of spans to fill */ + DDXPointPtr pptInit; /* pointer to list of start points */ + int *pwidthInit; /* pointer to list of n widths */ + int fSorted; +{ + GC_OP_PROLOGUE(pDrawable,pGC); + + TRC((stderr,"rfbFillSpans called\n")); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, + &((WindowPtr)pDrawable)->borderClip); + + (*pGC->ops->FillSpans) (pDrawable, pGC, nInit, pptInit,pwidthInit,fSorted); + + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); +} + +/* + * SetSpans - being very safe - the region being modified is the border clip + * region of the window. + */ + +static void +rfbSetSpans(DrawablePtr pDrawable, + GCPtr pGC, + char *psrc, + register DDXPointPtr ppt, + int *pwidth, + int nspans, + int fSorted) +{ + GC_OP_PROLOGUE(pDrawable,pGC); + + TRC((stderr,"rfbSetSpans called\n")); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, + &((WindowPtr)pDrawable)->borderClip); + + (*pGC->ops->SetSpans) (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted); + + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); +} + +/* + * PutImage - the region being modified is the rectangle of the + * PutImage (clipped to the window clip region). + */ + +static void +rfbPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y, int w, int h, int leftPad, int format, char *pBits) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPutImage called\n")); + + box.x1 = x + pDrawable->x; + box.y1 = y + pDrawable->y; + box.x2 = box.x1 + w; + box.y2 = box.y1 + h; + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + + (*pGC->ops->PutImage) (pDrawable, pGC, depth, x, y, w, h, + leftPad, format, pBits); + + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); +} + +/* + * CopyArea - the region being modified is the destination rectangle (clipped + * to the window clip region). + * If the client will accept CopyRect messages then use rfbCopyRegion + * to optimise the pending screen changes into a single "copy region" plus + * the ordinary modified region. + */ + +static RegionPtr +rfbCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy, int w, int h, int dstx, int dsty) +{ + rfbClientPtr cl; + RegionPtr rgn; + RegionRec srcRegion, dstRegion; + BoxRec box; + GC_OP_PROLOGUE(pDst, pGC); + + TRC((stderr,"rfbCopyArea called\n")); + + box.x1 = dstx + pDst->x; + box.y1 = dsty + pDst->y; + box.x2 = box.x1 + w; + box.y2 = box.y1 + h; + + SAFE_REGION_INIT(pDst->pScreen, &dstRegion, &box, 0); + REGION_INTERSECT(pDst->pScreen, &dstRegion, &dstRegion, + pGC->pCompositeClip); + + if ((pSrc->type == DRAWABLE_WINDOW) && (pSrc->pScreen == pDst->pScreen)) { + box.x1 = srcx + pSrc->x; + box.y1 = srcy + pSrc->y; + box.x2 = box.x1 + w; + box.y2 = box.y1 + h; + + for (cl = rfbClientHead; cl; cl = cl->next) { + if (cl->useCopyRect) { + SAFE_REGION_INIT(pSrc->pScreen, &srcRegion, &box, 0); + REGION_INTERSECT(pSrc->pScreen, &srcRegion, &srcRegion, + &((WindowPtr)pSrc)->clipList); + + rfbCopyRegion(pSrc->pScreen, cl, &srcRegion, &dstRegion, + dstx + pDst->x - srcx - pSrc->x, + dsty + pDst->y - srcy - pSrc->y); + + REGION_UNINIT(pSrc->pScreen, &srcRegion); + + } else { + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &dstRegion); + } + } + + } else { + + ADD_TO_MODIFIED_REGION(pDst->pScreen, &dstRegion); + } + + REGION_UNINIT(pDst->pScreen, &dstRegion); + + rgn = (*pGC->ops->CopyArea) (pSrc, pDst, pGC, srcx, srcy, w, h, + dstx, dsty); + + SCHEDULE_FB_UPDATE(pDst->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); + + return rgn; +} + + +/* + * CopyPlane - the region being modified is the destination rectangle (clipped + * to the window clip region). + */ + +static RegionPtr +rfbCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, register GCPtr pGC, int srcx, int srcy, int w, int h, int dstx, int dsty, unsigned long plane) +{ + RegionPtr rgn; + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDst, pGC); + + TRC((stderr,"rfbCopyPlane called\n")); + + box.x1 = dstx + pDst->x; + box.y1 = dsty + pDst->y; + box.x2 = box.x1 + w; + box.y2 = box.y1 + h; + + SAFE_REGION_INIT(pDst->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDst->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDst->pScreen, &tmpRegion); + + REGION_UNINIT(pDst->pScreen, &tmpRegion); + + rgn = (*pGC->ops->CopyPlane) (pSrc, pDst, pGC, srcx, srcy, w, h, + dstx, dsty, plane); + + SCHEDULE_FB_UPDATE(pDst->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); + + return rgn; +} + +/* + * PolyPoint - find the smallest rectangle which encloses the points drawn + * (and clip). + */ + +static void +rfbPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, xPoint *pts) +{ + int i; + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyPoint called\n")); + + if (npt) { + int minX = pts[0].x, maxX = pts[0].x; + int minY = pts[0].y, maxY = pts[0].y; + + if (mode == CoordModePrevious) + { + int x = pts[0].x, y = pts[0].y; + + for (i = 1; i < npt; i++) { + x += pts[i].x; + y += pts[i].y; + if (x < minX) minX = x; + if (x > maxX) maxX = x; + if (y < minY) minY = y; + if (y > maxY) maxY = y; + } + } + else + { + for (i = 1; i < npt; i++) { + if (pts[i].x < minX) minX = pts[i].x; + if (pts[i].x > maxX) maxX = pts[i].x; + if (pts[i].y < minY) minY = pts[i].y; + if (pts[i].y > maxY) maxY = pts[i].y; + } + } + + box.x1 = minX + pDrawable->x; + box.y1 = minY + pDrawable->y; + box.x2 = maxX + 1 + pDrawable->x; + box.y2 = maxY + 1 + pDrawable->y; + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->PolyPoint) (pDrawable, pGC, mode, npt, pts); + + if (npt) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyLines - take the union of bounding boxes around each line (and clip). + */ + +static void +rfbPolylines (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr ppts) +{ + RegionPtr tmpRegion; + xRectangle *rects; + int i, extra, nlines, lw; + int x1, x2, y1, y2; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolylines called\n")); + + if (npt) { + lw = pGC->lineWidth; + if (lw == 0) + lw = 1; + + if (npt == 1) + { + nlines = 1; + rects = (xRectangle *)xalloc(sizeof(xRectangle)); + if (!rects) { + FatalError("rfbPolylines: xalloc failed\n"); + } + + rects[0].x = ppts[0].x - lw + pDrawable->x; /* being safe here */ + rects[0].y = ppts[0].y - lw + pDrawable->y; + rects[0].width = 2*lw; + rects[0].height = 2*lw; + } + else + { + nlines = npt - 1; + rects = (xRectangle *)xalloc(nlines*sizeof(xRectangle)); + if (!rects) { + FatalError("rfbPolylines: xalloc failed\n"); + } + + /* + * mitered joins can project quite a way from + * the line end; the 11 degree miter limit limits + * this extension to lw / (2 * tan(11/2)), rounded up + * and converted to int yields 6 * lw + */ + + if (pGC->joinStyle == JoinMiter) { + extra = 6 * lw; + } else { + extra = lw / 2; + } + + x1 = ppts[0].x + pDrawable->x; + y1 = ppts[0].y + pDrawable->y; + + for (i = 0; i < nlines; i++) { + if (mode == CoordModeOrigin) { + x2 = pDrawable->x + ppts[i+1].x; + y2 = pDrawable->y + ppts[i+1].y; + } else { + x2 = x1 + ppts[i+1].x; + y2 = y1 + ppts[i+1].y; + } + + if (x1 > x2) { + rects[i].x = x2 - extra; + rects[i].width = x1 - x2 + 1 + 2 * extra; + } else { + rects[i].x = x1 - extra; + rects[i].width = x2 - x1 + 1 + 2 * extra; + } + + if (y1 > y2) { + rects[i].y = y2 - extra; + rects[i].height = y1 - y2 + 1 + 2 * extra; + } else { + rects[i].y = y1 - extra; + rects[i].height = y2 - y1 + 1 + 2 * extra; + } + + x1 = x2; + y1 = y2; + } + } + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, nlines, rects,CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)rects); + } + + (*pGC->ops->Polylines) (pDrawable, pGC, mode, npt, ppts); + + if (npt) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolySegment - take the union of bounding boxes around each segment (and + * clip). + */ + +static void +rfbPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *segs) +{ + RegionPtr tmpRegion; + xRectangle *rects; + int i, extra, lw; + + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolySegment called\n")); + + if (nseg) { + rects = (xRectangle *)xalloc(nseg*sizeof(xRectangle)); + if (!rects) { + FatalError("rfbPolySegment: xalloc failed\n"); + } + + lw = pGC->lineWidth; + if (lw == 0) + lw = 1; + + extra = lw / 2; + + for (i = 0; i < nseg; i++) + { + if (segs[i].x1 > segs[i].x2) { + rects[i].x = segs[i].x2 - extra + pDrawable->x; + rects[i].width = segs[i].x1 - segs[i].x2 + 1 + 2 * extra; + } else { + rects[i].x = segs[i].x1 - extra + pDrawable->x; + rects[i].width = segs[i].x2 - segs[i].x1 + 1 + 2 * extra; + } + + if (segs[i].y1 > segs[i].y2) { + rects[i].y = segs[i].y2 - extra + pDrawable->y; + rects[i].height = segs[i].y1 - segs[i].y2 + 1 + 2 * extra; + } else { + rects[i].y = segs[i].y1 - extra + pDrawable->y; + rects[i].height = segs[i].y2 - segs[i].y1 + 1 + 2 * extra; + } + } + + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, nseg, rects, CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)rects); + } + + (*pGC->ops->PolySegment) (pDrawable, pGC, nseg, segs); + + if (nseg) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyRectangle (rectangle outlines) - take the union of bounding boxes + * around each line (and clip). + */ + +static void +rfbPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nrects, xRectangle *rects) +{ + int i, extra, lw; + RegionPtr tmpRegion; + xRectangle *regRects; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyRectangle called\n")); + + if (nrects) { + regRects = (xRectangle *)xalloc(nrects*4*sizeof(xRectangle)); + if (!regRects) { + FatalError("rfbPolyRectangle: xalloc failed\n"); + } + + lw = pGC->lineWidth; + if (lw == 0) + lw = 1; + + extra = lw / 2; + + for (i = 0; i < nrects; i++) + { + regRects[i*4].x = rects[i].x - extra + pDrawable->x; + regRects[i*4].y = rects[i].y - extra + pDrawable->y; + regRects[i*4].width = rects[i].width + 1 + 2 * extra; + regRects[i*4].height = 1 + 2 * extra; + + regRects[i*4+1].x = rects[i].x - extra + pDrawable->x; + regRects[i*4+1].y = rects[i].y - extra + pDrawable->y; + regRects[i*4+1].width = 1 + 2 * extra; + regRects[i*4+1].height = rects[i].height + 1 + 2 * extra; + + regRects[i*4+2].x + = rects[i].x + rects[i].width - extra + pDrawable->x; + regRects[i*4+2].y = rects[i].y - extra + pDrawable->y; + regRects[i*4+2].width = 1 + 2 * extra; + regRects[i*4+2].height = rects[i].height + 1 + 2 * extra; + + regRects[i*4+3].x = rects[i].x - extra + pDrawable->x; + regRects[i*4+3].y + = rects[i].y + rects[i].height - extra + pDrawable->y; + regRects[i*4+3].width = rects[i].width + 1 + 2 * extra; + regRects[i*4+3].height = 1 + 2 * extra; + } + + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, nrects*4, + regRects, CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)regRects); + } + + (*pGC->ops->PolyRectangle) (pDrawable, pGC, nrects, rects); + + if (nrects) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyArc - take the union of bounding boxes around each arc (and clip). + * Bounding boxes assume each is a full circle / ellipse. + */ + +static void +rfbPolyArc(DrawablePtr pDrawable, register GCPtr pGC, int narcs, xArc *arcs) +{ + int i, extra, lw; + RegionPtr tmpRegion; + xRectangle *rects; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyArc called\n")); + + if (narcs) { + rects = (xRectangle *)xalloc(narcs*sizeof(xRectangle)); + if (!rects) { + FatalError("rfbPolyArc: xalloc failed\n"); + } + + lw = pGC->lineWidth; + if (lw == 0) + lw = 1; + + extra = lw / 2; + + for (i = 0; i < narcs; i++) + { + rects[i].x = arcs[i].x - extra + pDrawable->x; + rects[i].y = arcs[i].y - extra + pDrawable->y; + rects[i].width = arcs[i].width + lw; + rects[i].height = arcs[i].height + lw; + } + + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, narcs, rects, CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)rects); + } + + (*pGC->ops->PolyArc) (pDrawable, pGC, narcs, arcs); + + if (narcs) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * FillPolygon - take bounding box around polygon (and clip). + */ + +static void +rfbFillPolygon(register DrawablePtr pDrawable, register GCPtr pGC, int shape, int mode, int count, DDXPointPtr pts) +{ + int i; + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbFillPolygon called\n")); + + if (count) { + int minX = pts[0].x, maxX = pts[0].x; + int minY = pts[0].y, maxY = pts[0].y; + + if (mode == CoordModePrevious) + { + int x = pts[0].x, y = pts[0].y; + + for (i = 1; i < count; i++) { + x += pts[i].x; + y += pts[i].y; + if (x < minX) minX = x; + if (x > maxX) maxX = x; + if (y < minY) minY = y; + if (y > maxY) maxY = y; + } + } + else + { + for (i = 1; i < count; i++) { + if (pts[i].x < minX) minX = pts[i].x; + if (pts[i].x > maxX) maxX = pts[i].x; + if (pts[i].y < minY) minY = pts[i].y; + if (pts[i].y > maxY) maxY = pts[i].y; + } + } + + box.x1 = minX + pDrawable->x; + box.y1 = minY + pDrawable->y; + box.x2 = maxX + 1 + pDrawable->x; + box.y2 = maxY + 1 + pDrawable->y; + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->FillPolygon) (pDrawable, pGC, shape, mode, count, pts); + + if (count) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyFillRect - take the union of the given rectangles (and clip). + */ + +static void +rfbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrects, xRectangle *rects) +{ + RegionPtr tmpRegion; + xRectangle *regRects; + int i; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyFillRect called\n")); + + if (nrects) { + regRects = (xRectangle *)xalloc(nrects*sizeof(xRectangle)); + if (!regRects) { + FatalError("rfbPolyFillRect: xalloc failed\n"); + } + + for (i = 0; i < nrects; i++) { + regRects[i].x = rects[i].x + pDrawable->x; + regRects[i].y = rects[i].y + pDrawable->y; + regRects[i].width = rects[i].width; + regRects[i].height = rects[i].height; + } + + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, nrects, regRects, + CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)regRects); + } + + (*pGC->ops->PolyFillRect) (pDrawable, pGC, nrects, rects); + + if (nrects) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyFillArc - take the union of bounding boxes around each arc (and clip). + * Bounding boxes assume each is a full circle / ellipse. + */ + +static void +rfbPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *arcs) +{ + int i, extra, lw; + RegionPtr tmpRegion; + xRectangle *rects; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyFillArc called\n")); + + if (narcs) { + rects = (xRectangle *)xalloc(narcs*sizeof(xRectangle)); + if (!rects) { + FatalError("rfbPolyFillArc: xalloc failed\n"); + } + + lw = pGC->lineWidth; + if (lw == 0) + lw = 1; + + extra = lw / 2; + + for (i = 0; i < narcs; i++) + { + rects[i].x = arcs[i].x - extra + pDrawable->x; + rects[i].y = arcs[i].y - extra + pDrawable->y; + rects[i].width = arcs[i].width + lw; + rects[i].height = arcs[i].height + lw; + } + + tmpRegion = RECTS_TO_REGION(pDrawable->pScreen, narcs, rects, CT_NONE); + REGION_INTERSECT(pDrawable->pScreen, tmpRegion, tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, tmpRegion); + + REGION_DESTROY(pDrawable->pScreen, tmpRegion); + xfree((char *)rects); + } + + (*pGC->ops->PolyFillArc) (pDrawable, pGC, narcs, arcs); + + if (narcs) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * Get a rough bounding box around n characters of the given font. + */ + +static void GetTextBoundingBox(DrawablePtr pDrawable, FontPtr font, int x, int y, int n, BoxPtr pbox) +{ + int maxAscent, maxDescent, maxCharWidth; + + if (FONTASCENT(font) > FONTMAXBOUNDS(font,ascent)) + maxAscent = FONTASCENT(font); + else + maxAscent = FONTMAXBOUNDS(font,ascent); + + if (FONTDESCENT(font) > FONTMAXBOUNDS(font,descent)) + maxDescent = FONTDESCENT(font); + else + maxDescent = FONTMAXBOUNDS(font,descent); + + if (FONTMAXBOUNDS(font,rightSideBearing) > FONTMAXBOUNDS(font,characterWidth)) + maxCharWidth = FONTMAXBOUNDS(font,rightSideBearing); + else + maxCharWidth = FONTMAXBOUNDS(font,characterWidth); + + pbox->x1 = pDrawable->x + x; + pbox->y1 = pDrawable->y + y - maxAscent; + pbox->x2 = pbox->x1 + maxCharWidth * n; + pbox->y2 = pbox->y1 + maxAscent + maxDescent; + + if (FONTMINBOUNDS(font,leftSideBearing) < 0) { + pbox->x1 += FONTMINBOUNDS(font,leftSideBearing); + } +} + + +/* + * PolyText8 - use rough bounding box. + */ + +static int +rfbPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars) +{ + int ret; + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyText8 called '%.*s'\n",count,chars)); + + if (count) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + ret = (*pGC->ops->PolyText8) (pDrawable, pGC, x, y, count, chars); + + if (count) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); + return ret; +} + +/* + * PolyText16 - use rough bounding box. + */ + +static int +rfbPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars) +{ + int ret; + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyText16 called\n")); + + if (count) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + ret = (*pGC->ops->PolyText16) (pDrawable, pGC, x, y, count, chars); + + if (count) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); + return ret; +} + +/* + * ImageText8 - use rough bounding box. + */ + +static void +rfbImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbImageText8 called '%.*s'\n",count,chars)); + + if (count) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->ImageText8) (pDrawable, pGC, x, y, count, chars); + + if (count) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * ImageText16 - use rough bounding box. + */ + +static void +rfbImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbImageText16 called\n")); + + if (count) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, count, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->ImageText16) (pDrawable, pGC, x, y, count, chars); + + if (count) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * ImageGlyphBlt - use rough bounding box. + */ + +static void +rfbImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbImageGlyphBlt called\n")); + + if (nglyph) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, nglyph, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->ImageGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci,pglyphBase); + + if (nglyph) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PolyGlyphBlt - use rough bounding box. + */ + +static void +rfbPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPolyGlyphBlt called\n")); + + if (nglyph) { + GetTextBoundingBox(pDrawable, pGC->font, x, y, nglyph, &box); + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + } + + (*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); + + if (nglyph) { + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + } + + GC_OP_EPILOGUE(pGC); +} + +/* + * PushPixels - be fairly safe - region modified is intersection of the given + * rectangle with the window clip region. + */ + +static void +rfbPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable, int w, int h, int x, int y) +{ + RegionRec tmpRegion; + BoxRec box; + GC_OP_PROLOGUE(pDrawable, pGC); + + TRC((stderr,"rfbPushPixels called\n")); + + box.x1 = x + pDrawable->x; + box.y1 = y + pDrawable->y; + box.x2 = box.x1 + w; + box.y2 = box.y1 + h; + + SAFE_REGION_INIT(pDrawable->pScreen, &tmpRegion, &box, 0); + + REGION_INTERSECT(pDrawable->pScreen, &tmpRegion, &tmpRegion, + pGC->pCompositeClip); + + ADD_TO_MODIFIED_REGION(pDrawable->pScreen, &tmpRegion); + + REGION_UNINIT(pDrawable->pScreen, &tmpRegion); + + (*pGC->ops->PushPixels) (pGC, pBitMap, pDrawable, w, h, x, y); + + SCHEDULE_FB_UPDATE(pDrawable->pScreen, pVNC); + + GC_OP_EPILOGUE(pGC); +} + +#ifdef RENDER +void +rfbComposite( + CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height +){ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + VNCSCREENPTR(pScreen); + RegionRec tmpRegion; + BoxRec box; + PictureScreenPtr ps = GetPictureScreen(pScreen); + + box.x1 = pDst->pDrawable->x + xDst; + box.y1 = pDst->pDrawable->y + yDst; + box.x2 = box.x1 + width; + box.y2 = box.y1 + height; + + REGION_INIT(pScreen, &tmpRegion, &box, 0); + + ADD_TO_MODIFIED_REGION(pScreen, &tmpRegion); + + ps->Composite = pVNC->Composite; + (*ps->Composite)(op, pSrc, pMask, pDst, xSrc, ySrc, + xMask, yMask, xDst, yDst, width, height); + ps->Composite = rfbComposite; + + SCHEDULE_FB_UPDATE(pScreen, pVNC); + + REGION_UNINIT(pScreen, &tmpRegion); +} +#endif /* RENDER */ + +/****************************************************************************/ +/* + * Other functions + */ +/****************************************************************************/ + +/* + * rfbCopyRegion. Args are src and dst regions plus a translation (dx,dy). + * Takes these args together with the existing modified region and possibly an + * existing copy region and translation. Produces a combined modified region + * plus copy region and translation. Note that the copy region is the + * destination of the copy. + * + * First we trim parts of src which are invalid (ie in the modified region). + * Then we see if there is any overlap between the src and the existing copy + * region. If not then the two copies cannot be combined, so we choose + * whichever is bigger to form the basis of a new copy, while the other copy is + * just done the hard way by being added to the modified region. So if the + * existing copy is bigger then we simply add the destination of the new copy + * to the modified region and we're done. If the new copy is bigger, we add + * the old copy region to the modified region and behave as though there is no + * existing copy region. + * + * At this stage we now know that either the two copies can be combined, or + * that there is no existing copy. We temporarily add both the existing copy + * region and dst to the modified region (this is the entire area of the screen + * affected in any way). Finally we calculate the new copy region, and remove + * it from the modified region. + * + * Note: + * 1. The src region is modified by this routine. + * 2. When the copy region is empty, copyDX and copyDY MUST be set to zero. + */ + +static void +rfbCopyRegion(pScreen, cl, src, dst, dx, dy) + ScreenPtr pScreen; + rfbClientPtr cl; + RegionPtr src; + RegionPtr dst; + int dx, dy; +{ + RegionRec tmp; + + /* src = src - modifiedRegion */ + + REGION_SUBTRACT(pScreen, src, src, &cl->modifiedRegion); + + if (REGION_NOTEMPTY(pScreen, &cl->copyRegion)) { + + REGION_NULL(pScreen, &tmp); + REGION_INTERSECT(pScreen, &tmp, src, &cl->copyRegion); + + if (REGION_NOTEMPTY(pScreen, &tmp)) { + + /* if src and copyRegion overlap: + src = src intersect copyRegion */ + + REGION_COPY(pScreen, src, &tmp); + + } else { + + /* if no overlap, find bigger region */ + + int newArea = (((REGION_EXTENTS(pScreen,src))->x2 + - (REGION_EXTENTS(pScreen,src))->x1) + * ((REGION_EXTENTS(pScreen,src))->y2 + - (REGION_EXTENTS(pScreen,src))->y1)); + + int oldArea = (((REGION_EXTENTS(pScreen,&cl->copyRegion))->x2 + - (REGION_EXTENTS(pScreen,&cl->copyRegion))->x1) + * ((REGION_EXTENTS(pScreen,&cl->copyRegion))->y2 + - (REGION_EXTENTS(pScreen,&cl->copyRegion))->y1)); + + if (oldArea > newArea) { + + /* existing copy is bigger: + modifiedRegion = modifiedRegion union dst + copyRegion = copyRegion - dst + return */ + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + dst); + REGION_SUBTRACT(pScreen, &cl->copyRegion, &cl->copyRegion, + dst); + if (!REGION_NOTEMPTY(pScreen, &cl->copyRegion)) { + cl->copyDX = 0; + cl->copyDY = 0; + } + return; + } + + /* new copy is bigger: + modifiedRegion = modifiedRegion union copyRegion + copyRegion = empty */ + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &cl->copyRegion); + REGION_EMPTY(pScreen, &cl->copyRegion); + cl->copyDX = cl->copyDY = 0; + } + } + + + /* modifiedRegion = modifiedRegion union dst union copyRegion */ + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, dst); + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &cl->copyRegion); + + /* copyRegion = T(src) intersect dst */ + + REGION_TRANSLATE(pScreen, src, dx, dy); + REGION_INTERSECT(pScreen, &cl->copyRegion, src, dst); + + /* modifiedRegion = modifiedRegion - copyRegion */ + + REGION_SUBTRACT(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &cl->copyRegion); + + /* combine new translation T with existing translation */ + + if (REGION_NOTEMPTY(pScreen, &cl->copyRegion)) { + cl->copyDX += dx; + cl->copyDY += dy; + } else { + cl->copyDX = 0; + cl->copyDY = 0; + } +} + + +/* + * rfbDeferredUpdateCallback() is called when a client's deferredUpdateTimer + * goes off. + */ + +static CARD32 +rfbDeferredUpdateCallback(OsTimerPtr timer, CARD32 now, pointer arg) +{ + rfbClientPtr cl = (rfbClientPtr)arg; + + rfbSendFramebufferUpdate(cl->pScreen, cl); + + cl->deferredUpdateScheduled = FALSE; + return 0; +} + + +/* + * rfbScheduleDeferredUpdate() is called from the SCHEDULE_FB_UPDATE macro + * to schedule an update. + */ + +static void +rfbScheduleDeferredUpdate(ScreenPtr pScreen, rfbClientPtr cl) +{ + if (rfbDeferUpdateTime != 0) { + cl->deferredUpdateTimer = TimerSet(cl->deferredUpdateTimer, 0, + rfbDeferUpdateTime, + rfbDeferredUpdateCallback, cl); + cl->deferredUpdateScheduled = TRUE; + } else { + rfbSendFramebufferUpdate(pScreen, cl); + } +} + + +/* + * PrintRegion is useful for debugging. + */ + +#ifdef DEBUG +static void +PrintRegion(ScreenPtr pScreen, RegionPtr reg) +{ + int nrects = REGION_NUM_RECTS(reg); + int i; + + ErrorF("Region num rects %d extents %d,%d %d,%d\n",nrects, + (REGION_EXTENTS(pScreen,reg))->x1, + (REGION_EXTENTS(pScreen,reg))->y1, + (REGION_EXTENTS(pScreen,reg))->x2, + (REGION_EXTENTS(pScreen,reg))->y2); + + for (i = 0; i < nrects; i++) { + ErrorF(" rect %d,%d %dx%d\n", + REGION_RECTS(reg)[i].x1, + REGION_RECTS(reg)[i].y1, + REGION_RECTS(reg)[i].x2-REGION_RECTS(reg)[i].x1, + REGION_RECTS(reg)[i].y2-REGION_RECTS(reg)[i].y1); + } +} +#endif + +/** + * Allow scheduling updates from other functions in other files. + */ +void +rfbScheduleUpdate(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + SCHEDULE_FB_UPDATE(pScreen, pVNC); +} diff -pNur xorg-server-1.4.orig/hw/vnc/hextile.c xorg-server-1.4/hw/vnc/hextile.c --- xorg-server-1.4.orig/hw/vnc/hextile.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/hextile.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,350 @@ +/* + * hextile.c + * + * Routines to implement Hextile Encoding + * + * 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" + +static Bool sendHextiles8(rfbClientPtr cl, int x, int y, int w, int h); +static Bool sendHextiles16(rfbClientPtr cl, int x, int y, int w, int h); +static Bool sendHextiles32(rfbClientPtr cl, int x, int y, int w, int h); + + +/* + * rfbSendRectEncodingHextile - send a rectangle using hextile encoding. + */ + +Bool +rfbSendRectEncodingHextile(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + rfbFramebufferUpdateRectHeader rect; + + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + rect.r.x = Swap16IfLE(x); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingHextile); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbRectanglesSent[rfbEncodingHextile]++; + cl->rfbBytesSent[rfbEncodingHextile] += sz_rfbFramebufferUpdateRectHeader; + + switch (cl->format.bitsPerPixel) { + case 8: + return sendHextiles8(cl, x, y, w, h); + case 16: + return sendHextiles16(cl, x, y, w, h); + case 32: + return sendHextiles32(cl, x, y, w, h); + } + + rfbLog("rfbSendRectEncodingHextile: bpp %d?\n", cl->format.bitsPerPixel); + return FALSE; +} + + +#define PUT_PIXEL8(pix) (pVNC->updateBuf[pVNC->ublen++] = (pix)) + +#define PUT_PIXEL16(pix) (pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[0], \ + pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[1]) + +#define PUT_PIXEL32(pix) (pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[0], \ + pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[1], \ + pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[2], \ + pVNC->updateBuf[pVNC->ublen++] = ((char*)&(pix))[3]) + + +#define DEFINE_SEND_HEXTILES(bpp) \ + \ + \ +static Bool subrectEncode##bpp(ScreenPtr pScreen, CARD##bpp *data, int w, \ + int h, CARD##bpp bg, \ + CARD##bpp fg, Bool mono); \ +static void testColours##bpp(CARD##bpp *data, int size, Bool *mono, \ + Bool *solid, CARD##bpp *bg, CARD##bpp *fg); \ + \ + \ +/* \ + * rfbSendHextiles \ + */ \ + \ +static Bool \ +sendHextiles##bpp(cl, rx, ry, rw, rh) \ + rfbClientPtr cl; \ + int rx, ry, rw, rh; \ +{ \ + VNCSCREENPTR(cl->pScreen); \ + int x, y, w, h; \ + int startUblen; \ + CARD##bpp bg = 0, fg = 0, newBg, newFg; \ + Bool mono, solid; \ + Bool validBg = FALSE; \ + Bool validFg = FALSE; \ + CARD##bpp clientPixelData[16*16*(bpp/8)]; \ + \ + for (y = ry; y < ry+rh; y += 16) { \ + for (x = rx; x < rx+rw; x += 16) { \ + w = h = 16; \ + if (rx+rw - x < 16) \ + w = rx+rw - x; \ + if (ry+rh - y < 16) \ + h = ry+rh - y; \ + \ + if ((pVNC->ublen + 1 + (2 + 16 * 16) * (bpp/8)) > UPDATE_BUF_SIZE) { \ + if (!rfbSendUpdateBuf(cl)) \ + return FALSE; \ + } \ + \ + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, \ + &pVNC->rfbServerFormat, \ + &cl->format, (unsigned char *)clientPixelData, \ + pVNC->paddedWidthInBytes, w, h, x, y); \ + \ + startUblen = pVNC->ublen; \ + pVNC->updateBuf[startUblen] = 0; \ + pVNC->ublen++; \ + \ + testColours##bpp(clientPixelData, w * h, \ + &mono, &solid, &newBg, &newFg); \ + \ + if (!validBg || (newBg != bg)) { \ + validBg = TRUE; \ + bg = newBg; \ + pVNC->updateBuf[startUblen] |= rfbHextileBackgroundSpecified; \ + PUT_PIXEL##bpp(bg); \ + } \ + \ + if (solid) { \ + cl->rfbBytesSent[rfbEncodingHextile] += pVNC->ublen - startUblen; \ + continue; \ + } \ + \ + pVNC->updateBuf[startUblen] |= rfbHextileAnySubrects; \ + \ + if (mono) { \ + if (!validFg || (newFg != fg)) { \ + validFg = TRUE; \ + fg = newFg; \ + pVNC->updateBuf[startUblen] |= rfbHextileForegroundSpecified; \ + PUT_PIXEL##bpp(fg); \ + } \ + } else { \ + validFg = FALSE; \ + pVNC->updateBuf[startUblen] |= rfbHextileSubrectsColoured; \ + } \ + \ + if (!subrectEncode##bpp(cl->pScreen, clientPixelData, w, h, bg, fg, mono)) { \ + /* encoding was too large, use raw */ \ + validBg = FALSE; \ + validFg = FALSE; \ + pVNC->ublen = startUblen; \ + pVNC->updateBuf[pVNC->ublen++] = rfbHextileRaw; \ + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, \ + &pVNC->rfbServerFormat, &cl->format, \ + (unsigned char *)clientPixelData, \ + pVNC->paddedWidthInBytes, w, h, x, y); \ + \ + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)clientPixelData,\ + w * h * (bpp/8)); \ + \ + pVNC->ublen += w * h * (bpp/8); \ + } \ + \ + cl->rfbBytesSent[rfbEncodingHextile] += pVNC->ublen - startUblen; \ + } \ + } \ + \ + return TRUE; \ +} \ + \ + \ +static Bool \ +subrectEncode##bpp(ScreenPtr pScreen, CARD##bpp *data, int w, int h, \ + CARD##bpp bg, CARD##bpp fg, Bool mono) \ +{ \ + VNCSCREENPTR(pScreen); \ + CARD##bpp clientdata; \ + int x,y; \ + int i,j; \ + int hx=0,hy,vx=0,vy; \ + int hyflag; \ + CARD##bpp *seg; \ + CARD##bpp *line; \ + int hw,hh,vw,vh; \ + int thex,they,thew,theh; \ + int numsubs = 0; \ + int newLen; \ + int nSubrectsUblen; \ + \ + nSubrectsUblen = pVNC->ublen; \ + pVNC->ublen++; \ + \ + for (y=0; y<h; y++) { \ + line = data+(y*w); \ + for (x=0; x<w; x++) { \ + if (line[x] != bg) { \ + clientdata = line[x]; \ + hy = y-1; \ + hyflag = 1; \ + for (j=y; j<h; j++) { \ + seg = data+(j*w); \ + if (seg[x] != clientdata) {break;} \ + i = x; \ + while ((seg[i] == clientdata) && (i < w)) i += 1; \ + i -= 1; \ + if (j == y) vx = hx = i; \ + if (i < vx) vx = i; \ + if ((hyflag > 0) && (i >= hx)) { \ + hy += 1; \ + } else { \ + hyflag = 0; \ + } \ + } \ + vy = j-1; \ + \ + /* We now have two possible subrects: (x,y,hx,hy) and \ + * (x,y,vx,vy). We'll choose the bigger of the two. \ + */ \ + hw = hx-x+1; \ + hh = hy-y+1; \ + vw = vx-x+1; \ + vh = vy-y+1; \ + \ + thex = x; \ + they = y; \ + \ + if ((hw*hh) > (vw*vh)) { \ + thew = hw; \ + theh = hh; \ + } else { \ + thew = vw; \ + theh = vh; \ + } \ + \ + if (mono) { \ + newLen = pVNC->ublen - nSubrectsUblen + 2; \ + } else { \ + newLen = pVNC->ublen - nSubrectsUblen + bpp/8 + 2; \ + } \ + \ + if (newLen > (w * h * (bpp/8))) \ + return FALSE; \ + \ + numsubs += 1; \ + \ + if (!mono) PUT_PIXEL##bpp(clientdata); \ + \ + pVNC->updateBuf[pVNC->ublen++] = rfbHextilePackXY(thex,they); \ + pVNC->updateBuf[pVNC->ublen++] = rfbHextilePackWH(thew,theh); \ + \ + /* \ + * Now mark the subrect as done. \ + */ \ + for (j=they; j < (they+theh); j++) { \ + for (i=thex; i < (thex+thew); i++) { \ + data[j*w+i] = bg; \ + } \ + } \ + } \ + } \ + } \ + \ + pVNC->updateBuf[nSubrectsUblen] = numsubs; \ + \ + return TRUE; \ +} \ + \ + \ +/* \ + * testColours() tests if there are one (solid), two (mono) or more \ + * colours in a tile and gets a reasonable guess at the best background \ + * pixel, and the foreground pixel for mono. \ + */ \ + \ +static void \ +testColours##bpp(data,size,mono,solid,bg,fg) \ + CARD##bpp *data; \ + int size; \ + Bool *mono; \ + Bool *solid; \ + CARD##bpp *bg; \ + CARD##bpp *fg; \ +{ \ + CARD##bpp colour1 = 0, colour2 = 0; \ + int n1 = 0, n2 = 0; \ + *mono = TRUE; \ + *solid = TRUE; \ + \ + for (; size > 0; size--, data++) { \ + \ + if (n1 == 0) \ + colour1 = *data; \ + \ + if (*data == colour1) { \ + n1++; \ + continue; \ + } \ + \ + if (n2 == 0) { \ + *solid = FALSE; \ + colour2 = *data; \ + } \ + \ + if (*data == colour2) { \ + n2++; \ + continue; \ + } \ + \ + *mono = FALSE; \ + break; \ + } \ + \ + if (n1 > n2) { \ + *bg = colour1; \ + *fg = colour2; \ + } else { \ + *bg = colour2; \ + *fg = colour1; \ + } \ +} + +DEFINE_SEND_HEXTILES(8) +DEFINE_SEND_HEXTILES(16) +DEFINE_SEND_HEXTILES(32) diff -pNur xorg-server-1.4.orig/hw/vnc/httpd.c xorg-server-1.4/hw/vnc/httpd.c --- xorg-server-1.4.orig/hw/vnc/httpd.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/httpd.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,519 @@ +/* + * httpd.c - a simple HTTP server + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2002 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 <sys/types.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <fcntl.h> +#include <errno.h> +#include <arpa/inet.h> +#include <pwd.h> +#include <netdb.h> + +#ifndef USE_LIBWRAP +#define USE_LIBWRAP 0 +#endif +#if USE_LIBWRAP +#include <tcpd.h> +#endif + +#include "rfb.h" + +#define NOT_FOUND_STR "HTTP/1.0 404 Not found\r\n\r\n" \ + "<HEAD><TITLE>File Not Found</TITLE></HEAD>\n" \ + "<BODY><H1>File Not Found</H1></BODY>\n" + +#define OK_STR "HTTP/1.0 200 OK\r\n\r\n" + +static void httpProcessInput(ScreenPtr pScreen); +static Bool compareAndSkip(char **ptr, const char *str); +static Bool parseParams(const char *request, char *result, int max_bytes); +static Bool validateString(char *str); + +/* + * httpInitSockets sets up the TCP socket to listen for HTTP connections. + */ + +Bool +httpInitSockets(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + + if (!pVNC->httpDir) + return FALSE; + + pVNC->buf_filled = 0; + + if (pVNC->httpPort == 0) { + pVNC->httpPort = 5800 + atoi(display) + pScreen->myNum; + } + + if ((pVNC->httpListenSock = ListenOnTCPPort(pScreen, pVNC->httpPort)) < 0) { + rfbLog("ListenOnTCPPort %d failed\n",pVNC->httpPort); + pVNC->httpPort = 0; + return FALSE; + } + + rfbLog("Listening for HTTP connections on TCP port %d\n", pVNC->httpPort); + rfbLog(" URL http://%s:%d\n",rfbThisHost,pVNC->httpPort); + + AddEnabledDevice(pVNC->httpListenSock); + + return TRUE; +} + + +/* + * httpCheckFds is called from ProcessInputEvents to check for input on the + * HTTP socket(s). If there is input to process, httpProcessInput is called. + */ + +void +httpCheckFds(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + int nfds; + fd_set fds; + struct timeval tv; + struct sockaddr_in addr; + SOCKLEN_T addrlen = sizeof(addr); + + if (!pVNC->httpDir) + return; + + FD_ZERO(&fds); + FD_SET(pVNC->httpListenSock, &fds); + if (pVNC->httpSock >= 0) { + FD_SET(pVNC->httpSock, &fds); + } + tv.tv_sec = 0; + tv.tv_usec = 0; + nfds = select(max(pVNC->httpSock,pVNC->httpListenSock) + 1, &fds, NULL, NULL, &tv); + if (nfds == 0) { + return; + } + if (nfds < 0) { + if (errno != EINTR) + rfbLogPerror("httpCheckFds: select"); + return; + } + + if ((pVNC->httpSock >= 0) && FD_ISSET(pVNC->httpSock, &fds)) { + httpProcessInput(pScreen); + } + + if (FD_ISSET(pVNC->httpListenSock, &fds)) { + int flags; + + if (pVNC->httpSock >= 0) close(pVNC->httpSock); + + if ((pVNC->httpSock = accept(pVNC->httpListenSock, + (struct sockaddr *)&addr, &addrlen)) < 0) { + rfbLogPerror("httpCheckFds: accept"); + return; + } + +#if USE_LIBWRAP + if (!hosts_ctl("Xvnc", STRING_UNKNOWN, inet_ntoa(addr.sin_addr), + STRING_UNKNOWN)) { + rfbLog("Rejected HTTP connection from client %s\n", + inet_ntoa(addr.sin_addr)); + close(pVNC->httpSock); + pVNC->httpSock = -1; + return; + } +#endif + + flags = fcntl (pVNC->httpSock, F_GETFL); + + if (flags == -1 || + fcntl (pVNC->httpSock, F_SETFL, flags | O_NONBLOCK) == -1) { + rfbLogPerror("httpCheckFds: fcntl"); + close (pVNC->httpSock); + pVNC->httpSock = -1; + return; + } + + AddEnabledDevice(pVNC->httpSock); + } +} + + +static void +httpCloseSock(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + close(pVNC->httpSock); + RemoveEnabledDevice(pVNC->httpSock); + pVNC->httpSock = -1; + pVNC->buf_filled = 0; +} + + +/* + * httpProcessInput is called when input is received on the HTTP socket. + */ + +static void +httpProcessInput(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + struct sockaddr_in addr; + SOCKLEN_T addrlen = sizeof(addr); + char fullFname[512]; + char params[1024]; + char *ptr; + char *fname; + int maxFnameLen; + int fd; + Bool performSubstitutions = FALSE; + char str[256]; + struct passwd *user = getpwuid(getuid()); + + if (strlen(pVNC->httpDir) > 255) { + rfbLog("-httpd directory too long\n"); + httpCloseSock(pScreen); + return; + } + strcpy(fullFname, pVNC->httpDir); + fname = &fullFname[strlen(fullFname)]; + maxFnameLen = 511 - strlen(fullFname); + + /* Read data from the HTTP client until we get a complete request. */ + while (1) { + ssize_t got = read (pVNC->httpSock, pVNC->buf + pVNC->buf_filled, + sizeof (pVNC->buf) - pVNC->buf_filled - 1); + + if (got <= 0) { + if (got == 0) { + rfbLog("httpd: premature connection close\n"); + } else { + if (errno == EAGAIN) { + return; + } + rfbLogPerror("httpProcessInput: read"); + } + httpCloseSock(pScreen); + return; + } + + pVNC->buf_filled += got; + pVNC->buf[pVNC->buf_filled] = '\0'; + + /* Is it complete yet (is there a blank line)? */ + if (strstr (pVNC->buf, "\r\r") || strstr (pVNC->buf, "\n\n") || + strstr (pVNC->buf, "\r\n\r\n") || strstr (pVNC->buf, "\n\r\n\r")) + break; + } + + /* Process the request. */ + if (strncmp(pVNC->buf, "GET ", 4)) { + rfbLog("httpd: no GET line\n"); + httpCloseSock(pScreen); + return; + } else { + /* Only use the first line. */ + pVNC->buf[strcspn(pVNC->buf, "\n\r")] = '\0'; + } + + if (strlen(pVNC->buf) > maxFnameLen) { + rfbLog("httpd: GET line too long\n"); + httpCloseSock(pScreen); + return; + } + + if (sscanf(pVNC->buf, "GET %s HTTP/1.0", fname) != 1) { + rfbLog("httpd: couldn't parse GET line\n"); + httpCloseSock(pScreen); + return; + } + + if (fname[0] != '/') { + rfbLog("httpd: filename didn't begin with '/'\n"); + WriteExact(pVNC->httpSock, NOT_FOUND_STR, strlen(NOT_FOUND_STR)); + httpCloseSock(pScreen); + return; + } + + if (strchr(fname+1, '/') != NULL) { + rfbLog("httpd: asking for file in other directory\n"); + WriteExact(pVNC->httpSock, NOT_FOUND_STR, strlen(NOT_FOUND_STR)); + httpCloseSock(pScreen); + return; + } + + getpeername(pVNC->httpSock, (struct sockaddr *)&addr, &addrlen); + rfbLog("httpd: get '%s' for %s\n", fname+1, + inet_ntoa(addr.sin_addr)); + + /* Extract parameters from the URL string if necessary */ + + params[0] = '\0'; + ptr = strchr(fname, '?'); + if (ptr != NULL) { + *ptr = '\0'; + if (!parseParams(&ptr[1], params, 1024)) { + params[0] = '\0'; + rfbLog("httpd: bad parameters in the URL\n"); + } + } + + /* If we were asked for '/', actually read the file index.vnc */ + + if (strcmp(fname, "/") == 0) { + strcpy(fname, "/index.vnc"); + rfbLog("httpd: defaulting to '%s'\n", fname+1); + } + + /* Substitutions are performed on files ending .vnc */ + + if (strlen(fname) >= 4 && strcmp(&fname[strlen(fname)-4], ".vnc") == 0) { + performSubstitutions = TRUE; + } + + /* Open the file */ + + if ((fd = open(fullFname, O_RDONLY)) < 0) { + rfbLogPerror("httpProcessInput: open"); + WriteExact(pVNC->httpSock, NOT_FOUND_STR, strlen(NOT_FOUND_STR)); + httpCloseSock(pScreen); + return; + } + + WriteExact(pVNC->httpSock, OK_STR, strlen(OK_STR)); + + while (1) { + int n = read(fd, pVNC->buf, HTTP_BUF_SIZE-1); + if (n < 0) { + rfbLogPerror("httpProcessInput: read"); + close(fd); + httpCloseSock(pScreen); + return; + } + + if (n == 0) + break; + + if (performSubstitutions) { + + /* Substitute $WIDTH, $HEIGHT, etc with the appropriate values. + This won't quite work properly if the .vnc file is longer than + HTTP_BUF_SIZE, but it's reasonable to assume that .vnc files will + always be short. */ + + char *ptr = pVNC->buf; + char *dollar; + pVNC->buf[n] = 0; /* make sure it's null-terminated */ + + while ((dollar = strchr(ptr, '$'))) { + WriteExact(pVNC->httpSock, ptr, (dollar - ptr)); + + ptr = dollar; + + if (compareAndSkip(&ptr, "$WIDTH")) { + + sprintf(str, "%d", pVNC->width); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$HEIGHT")) { + + sprintf(str, "%d", pVNC->height); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$APPLETWIDTH")) { + + sprintf(str, "%d", pVNC->width); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$APPLETHEIGHT")) { + + sprintf(str, "%d", pVNC->height + 32); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$PORT")) { + + sprintf(str, "%d", pVNC->rfbPort); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$DESKTOP")) { + + WriteExact(pVNC->httpSock, desktopName, strlen(desktopName)); + + } else if (compareAndSkip(&ptr, "$DISPLAY")) { + + sprintf(str, "%s:%s", rfbThisHost, display); + WriteExact(pVNC->httpSock, str, strlen(str)); + + } else if (compareAndSkip(&ptr, "$USER")) { + + if (user) { + WriteExact(pVNC->httpSock, user->pw_name, + strlen(user->pw_name)); + } else { + WriteExact(pVNC->httpSock, "?", 1); + } + + } else if (compareAndSkip(&ptr, "$PARAMS")) { + + if (params[0] != '\0') + WriteExact(pVNC->httpSock, params, strlen(params)); + + } else { + if (!compareAndSkip(&ptr, "$$")) + ptr++; + + if (WriteExact(pVNC->httpSock, "$", 1) < 0) { + close(fd); + httpCloseSock(pScreen); + return; + } + } + } + if (WriteExact(pVNC->httpSock, ptr, (&pVNC->buf[n] - ptr)) < 0) + break; + + } else { + + /* For files not ending .vnc, just write out the buffer */ + + if (WriteExact(pVNC->httpSock, pVNC->buf, n) < 0) + break; + } + } + + close(fd); + httpCloseSock(pScreen); +} + + +static Bool +compareAndSkip(char **ptr, const char *str) +{ + if (strncmp(*ptr, str, strlen(str)) == 0) { + *ptr += strlen(str); + return TRUE; + } + + return FALSE; +} + +/* + * Parse the request tail after the '?' character, and format a sequence + * of <param> tags for inclusion into an HTML page with embedded applet. + */ + +static Bool +parseParams(const char *request, char *result, int max_bytes) +{ + char param_request[128]; + char param_formatted[196]; + const char *tail; + char *delim_ptr; + char *value_str; + int cur_bytes, len; + + result[0] = '\0'; + cur_bytes = 0; + + tail = request; + for (;;) { + /* Copy individual "name=value" string into a buffer */ + delim_ptr = strchr((char *)tail, '&'); + if (delim_ptr == NULL) { + if (strlen(tail) >= sizeof(param_request)) { + return FALSE; + } + strcpy(param_request, tail); + } else { + len = delim_ptr - tail; + if (len >= sizeof(param_request)) { + return FALSE; + } + memcpy(param_request, tail, len); + param_request[len] = '\0'; + } + + /* Split the request into parameter name and value */ + value_str = strchr(¶m_request[1], '='); + if (value_str == NULL) { + return FALSE; + } + *value_str++ = '\0'; + if (strlen(value_str) == 0) { + return FALSE; + } + + /* Validate both parameter name and value */ + if (!validateString(param_request) || !validateString(value_str)) { + return FALSE; + } + + /* Prepare HTML-formatted representation of the name=value pair */ + len = sprintf(param_formatted, + "<PARAM NAME=\"%s\" VALUE=\"%s\">\n", + param_request, value_str); + if (cur_bytes + len + 1 > max_bytes) { + return FALSE; + } + strcat(result, param_formatted); + cur_bytes += len; + + /* Go to the next parameter */ + if (delim_ptr == NULL) { + break; + } + tail = delim_ptr + 1; + } + return TRUE; +} + +/* + * Check if the string consists only of alphanumeric characters, '+' + * signs, underscores, and dots. Replace all '+' signs with spaces. + */ + +static Bool +validateString(char *str) +{ + char *ptr; + + for (ptr = str; *ptr != '\0'; ptr++) { + if (!isalnum(*ptr) && *ptr != '_' && *ptr != '.') { + if (*ptr == '+') { + *ptr = ' '; + } else { + return FALSE; + } + } + } + return TRUE; +} + diff -pNur xorg-server-1.4.orig/hw/vnc/init.c xorg-server-1.4/hw/vnc/init.c --- xorg-server-1.4.orig/hw/vnc/init.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/init.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,1075 @@ +/* + * init.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. + +*/ + +/* Use ``#define CORBA'' to enable CORBA control interface */ + +/* XXX this definition should probably go elsewhere */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#ifndef XVNCRELEASE +#define XVNCRELEASE "X.org/xf4vnc custom version" +#endif + +#include <stdio.h> +#include <unistd.h> +#include <stdarg.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#include "X11/X.h" +#define NEED_EVENTS +#include "X11/Xproto.h" +#include "X11/Xos.h" +#include "scrnintstr.h" +#include "servermd.h" +#include "fb.h" +#include "mibstore.h" +#include "colormapst.h" +#include "gcstruct.h" +#include "input.h" +#include "mipointer.h" +#include "dixstruct.h" +#include <X11/Xatom.h> +#include <errno.h> +#include <sys/param.h> +#include "dix.h" +#include "micmap.h" +#include "rfb.h" + +#ifdef CORBA +#include <vncserverctrl.h> +#endif + +#define RFB_DEFAULT_WIDTH 640 +#define RFB_DEFAULT_HEIGHT 480 +#define RFB_DEFAULT_DEPTH 8 +#define RFB_DEFAULT_WHITEPIXEL 0 +#define RFB_DEFAULT_BLACKPIXEL 1 + +static unsigned long VNCGeneration = 0; +rfbScreenInfo rfbScreen; +int rfbGCIndex; +extern char dispatchExceptionAtReset; + +extern void VncExtensionInit(void); + +static Bool initOutputCalled = FALSE; +static Bool noCursor = FALSE; +char *desktopName = "x11"; + +char rfbThisHost[256]; + +Atom VNC_LAST_CLIENT_ID; +Atom VNC_CONNECT; + +#if 0 +static HWEventQueueType alwaysCheckForInput[2] = { 0, 1 }; +static HWEventQueueType *mieqCheckForInput[2]; +#endif + +static char primaryOrder[4] = ""; +static int redBits, greenBits, blueBits; + +static Bool rfbScreenInit(int index, ScreenPtr pScreen, int argc, + char **argv); +static int rfbKeybdProc(DeviceIntPtr pDevice, int onoff); +static int rfbMouseProc(DeviceIntPtr pDevice, int onoff); +static Bool CheckDisplayNumber(int n); + +static Bool rfbAlwaysTrue(void); +static unsigned char *rfbAllocateFramebufferMemory(rfbScreenInfoPtr prfb); +static Bool rfbCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y); +static void rfbCrossScreen(ScreenPtr pScreen, Bool entering); + + + +static void +PointerWarpCursor(ScreenPtr pScreen, int x, int y) +{ +#if 0 + DeviceIntPtr pDev = NULL; + miPointerSetPosition(pDev, &x, &y, GetTimeInMillis()); +#endif +} + + +static miPointerScreenFuncRec rfbPointerCursorFuncs = { + rfbCursorOffScreen, + rfbCrossScreen, + PointerWarpCursor, + NULL/*dmxeqEnqueue*/, + NULL/*dmxeqSwitchScreen*/ +}; + + +int inetdSock = -1; +static char inetdDisplayNumStr[10]; + + +void +DDXRingBell(int volume, int pitch, int duration) +{ + /* NO-OP - stub to solve link problem */ +} + + +/* + * ddxProcessArgument is our first entry point and will be called at the + * very start for each argument. It is not called again on server reset. + */ + +int +ddxProcessArgument (argc, argv, i) + int argc; + char *argv[]; + int i; +{ + VNCSCREENPTR(screenInfo.screens[i]); + static Bool firstTime = TRUE; + + if (firstTime) + { + pVNC->width = RFB_DEFAULT_WIDTH; + pVNC->height = RFB_DEFAULT_HEIGHT; + pVNC->depth = RFB_DEFAULT_DEPTH; + pVNC->blackPixel = RFB_DEFAULT_BLACKPIXEL; + pVNC->whitePixel = RFB_DEFAULT_WHITEPIXEL; + pVNC->pfbMemory = NULL; + pVNC->httpPort = 0; + pVNC->httpDir = NULL; + pVNC->rfbAuthPasswdFile = NULL; + pVNC->udpPort = 0; + pVNC->rfbPort = 0; + pVNC->rdpPort = 3389; + noCursor = FALSE; + pVNC->loginAuthEnabled = FALSE; + pVNC->rfbAlwaysShared = FALSE; + pVNC->rfbNeverShared = FALSE; + pVNC->rfbDontDisconnect = FALSE; + pVNC->rfbViewOnly = FALSE; + + gethostname(rfbThisHost, 255); + pVNC->interface.s_addr = htonl (INADDR_ANY); + firstTime = FALSE; + } + + if (strcmp (argv[i], "-geometry") == 0) /* -geometry WxH */ + { + if (i + 1 >= argc) UseMsg(); + if (sscanf(argv[i+1],"%dx%d", + &pVNC->width,&pVNC->height) != 2) { + ErrorF("Invalid geometry %s\n", argv[i+1]); + UseMsg(); + } +#ifdef CORBA + screenWidth= pVNC->width; + screenHeight= pVNC->height; +#endif + return 2; + } + + if (strcmp (argv[i], "-depth") == 0) /* -depth D */ + { + if (i + 1 >= argc) UseMsg(); + pVNC->depth = atoi(argv[i+1]); +#ifdef CORBA + screenDepth= pVNC->depth; +#endif + return 2; + } + + if (strcmp (argv[i], "-pixelformat") == 0) { + if (i + 1 >= argc) UseMsg(); + if (sscanf(argv[i+1], "%3s", primaryOrder) < 1) { + ErrorF("Invalid pixel format %s\n", argv[i+1]); + UseMsg(); + } + + return 2; + } + + if (strcmp (argv[i], "-blackpixel") == 0) { /* -blackpixel n */ + if (i + 1 >= argc) UseMsg(); + pVNC->blackPixel = atoi(argv[i+1]); + return 2; + } + + if (strcmp (argv[i], "-whitepixel") == 0) { /* -whitepixel n */ + if (i + 1 >= argc) UseMsg(); + pVNC->whitePixel = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-udpinputport") == 0) { /* -udpinputport port */ + if (i + 1 >= argc) UseMsg(); + pVNC->udpPort = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-rfbport") == 0) { /* -rfbport port */ + if (i + 1 >= argc) UseMsg(); + pVNC->rfbPort = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-rfbwait") == 0) { /* -rfbwait ms */ + if (i + 1 >= argc) UseMsg(); + rfbMaxClientWait = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-nocursor") == 0) { + noCursor = TRUE; + return 1; + } + + if (strcmp(argv[i], "-rfbauth") == 0) { /* -rfbauth passwd-file */ + if (i + 1 >= argc) UseMsg(); + pVNC->rfbAuthPasswdFile = argv[i+1]; + return 2; + } + + if (strcmp(argv[i], "-loginauth") == 0) { + if (geteuid() == 0) { + /* Only when run as root! */ + pVNC->loginAuthEnabled = TRUE; + } + return 1; + } + + if (strcmp(argv[i], "-httpd") == 0) { + if (i + 1 >= argc) UseMsg(); + pVNC->httpDir = argv[i+1]; + return 2; + } + + if (strcmp(argv[i], "-httpport") == 0) { + if (i + 1 >= argc) UseMsg(); + pVNC->httpPort = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-deferupdate") == 0) { /* -deferupdate ms */ + if (i + 1 >= argc) UseMsg(); + rfbDeferUpdateTime = atoi(argv[i+1]); + return 2; + } + + if (strcmp(argv[i], "-economictranslate") == 0) { + rfbEconomicTranslate = TRUE; + return 1; + } + + if (strcmp(argv[i], "-lazytight") == 0) { + rfbTightDisableGradient = TRUE; + return 1; + } + + if (strcmp(argv[i], "-desktop") == 0) { /* -desktop desktop-name */ + if (i + 1 >= argc) UseMsg(); + desktopName = argv[i+1]; + return 2; + } + +#if 0 /* not deemed useful on standalone server - leave for completeness */ + if (strcmp(argv[i], "-useraccept") == 0) { + pVNC->rfbUserAccept = TRUE; + return 1; + } +#endif + + if (strcmp(argv[i], "-alwaysshared") == 0) { + pVNC->rfbAlwaysShared = TRUE; + return 1; + } + + if (strcmp(argv[i], "-nevershared") == 0) { + pVNC->rfbNeverShared = TRUE; + return 1; + } + + if (strcmp(argv[i], "-dontdisconnect") == 0) { + pVNC->rfbDontDisconnect = TRUE; + return 1; + } + + /* Run server in view-only mode - Ehud Karni SW */ + if (strcmp(argv[i], "-viewonly") == 0) { + pVNC->rfbViewOnly = TRUE; + return 1; + } + + if (strcmp(argv[i], "-localhost") == 0) { + pVNC->interface.s_addr = htonl (INADDR_LOOPBACK); + return 1; + } + + if (strcmp(argv[i], "-interface") == 0) { /* -interface ipaddr */ + struct in_addr got; + unsigned long octet; + char *p, *end; + int q; + got.s_addr = 0; + if (i + 1 >= argc) { + UseMsg(); + return 2; + } + if (pVNC->interface.s_addr != htonl (INADDR_ANY)) { + /* Already set (-localhost?). */ + return 2; + } + p = argv[i + 1]; + for (q = 0; q < 4; q++) { + octet = strtoul (p, &end, 10); + if (p == end || octet > 255) { + UseMsg (); + return 2; + } + if ((q < 3 && *end != '.') || + (q == 3 && *end != '\0')) { + UseMsg (); + return 2; + } + got.s_addr = (got.s_addr << 8) | octet; + p = end + 1; + } + pVNC->interface.s_addr = htonl (got.s_addr); + return 2; + } + + if (strcmp(argv[i], "-inetd") == 0) { /* -inetd */ + int n; + for (n = 1; n < 100; n++) { + if (CheckDisplayNumber(n)) + break; + } + + if (n >= 100) + FatalError("-inetd: couldn't find free display number"); + + sprintf(inetdDisplayNumStr, "%d", n); + display = inetdDisplayNumStr; + + /* fds 0, 1 and 2 (stdin, out and err) are all the same socket to the + RFB client. OsInit() closes stdout and stdin, and we don't want + stderr to go to the RFB client, so make the client socket 3 and + close stderr. OsInit() will redirect stderr logging to an + appropriate log file or /dev/null if that doesn't work. */ + + dup2(0,3); + inetdSock = 3; + close(2); + + return 1; + } + + if (strcmp(argv[i], "-version") == 0) { + ErrorF("Xvnc version %s\n", XVNCRELEASE); + exit(0); + } + + if (inetdSock != -1 && argv[i][0] == ':') { + FatalError("can't specify both -inetd and :displaynumber"); + } + + return 0; +} + + +/* + * InitOutput is called every time the server resets. It should call + * AddScreen for each screen (FIXME - but we only ever have one), + * and in turn this will call rfbScreenInit. + */ + +/* Common pixmap formats */ + +static PixmapFormatRec formats[MAXFORMATS] = { + { 1, 1, BITMAP_SCANLINE_PAD }, + { 4, 8, BITMAP_SCANLINE_PAD }, + { 8, 8, BITMAP_SCANLINE_PAD }, + { 15, 16, BITMAP_SCANLINE_PAD }, + { 16, 16, BITMAP_SCANLINE_PAD }, + { 24, 32, BITMAP_SCANLINE_PAD }, +#ifdef RENDER + { 32, 32, BITMAP_SCANLINE_PAD }, +#endif +}; +#ifdef RENDER +static int numFormats = 7; +#else +static int numFormats = 6; +#endif + +void +InitOutput(screenInfo, argc, argv) + ScreenInfo *screenInfo; + int argc; + char **argv; +{ + int i; + initOutputCalled = TRUE; + + rfbLog("Xvnc version %s\n", XVNCRELEASE); + rfbLog("Copyright (C) 2001-2004 Alan Hourihane.\n"); + rfbLog("Copyright (C) 2000-2004 Constantin Kaplinsky\n"); + rfbLog("Copyright (C) 1999 AT&T Laboratories Cambridge\n"); + rfbLog("All Rights Reserved.\n"); + rfbLog("See http://www.tightvnc.com/ for information on TightVNC\n"); + rfbLog("See http://xf4vnc.sf.net for xf4vnc-specific information\n"); + rfbLog("Desktop name '%s' (%s:%s)\n",desktopName,rfbThisHost,display); + rfbLog("Protocol versions supported: %d.%d, %d.%d\n", + rfbProtocolMajorVersion, rfbProtocolMinorVersion, + rfbProtocolMajorVersion, rfbProtocolFallbackMinorVersion); + + VNC_LAST_CLIENT_ID = MakeAtom("VNC_LAST_CLIENT_ID", + strlen("VNC_LAST_CLIENT_ID"), TRUE); + VNC_CONNECT = MakeAtom("VNC_CONNECT", strlen("VNC_CONNECT"), TRUE); + + /* initialize pixmap formats */ + + screenInfo->imageByteOrder = IMAGE_BYTE_ORDER; + screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT; + screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD; + screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER; + screenInfo->numPixmapFormats = numFormats; + for (i = 0; i < numFormats; i++) + screenInfo->formats[i] = formats[i]; + + rfbGCIndex = AllocateGCPrivateIndex(); + if (rfbGCIndex < 0) { + FatalError("InitOutput: AllocateGCPrivateIndex failed\n"); + } + + /* initialize screen */ + + if (AddScreen(rfbScreenInit, argc, argv) == -1) { + FatalError("Couldn't add screen"); + } + +#ifdef CORBA + initialiseCORBA(argc, argv, desktopName); +#endif +} + +static void +rfbWakeupHandler ( + int i, + pointer blockData, + unsigned long err, + pointer pReadmask +){ + ScreenPtr pScreen = screenInfo.screens[i]; + VNCSCREENPTR(pScreen); + int e = (int)err; + + if (e < 0) + goto SKIPME; + + rfbRootPropertyChange(pScreen); + +#if XFREE86VNC + if (pScrn->vtSema) { + rfbCheckFds(pScreen); + httpCheckFds(pScreen); +#if 0 + rdpCheckFds(pScreen); +#endif +#ifdef CORBA + corbaCheckFds(); +#endif + } else { + rfbCheckFds(pScreen); +#if 0 + rdpCheckFds(pScreen); +#endif + } +#else + rfbCheckFds(pScreen); + httpCheckFds(pScreen); +#if 0 + rdpCheckFds(pScreen); +#endif +#ifdef CORBA + corbaCheckFds(); +#endif +#endif + +SKIPME: + + pScreen->WakeupHandler = pVNC->WakeupHandler; + (*pScreen->WakeupHandler) (i, blockData, err, pReadmask); + pScreen->WakeupHandler = rfbWakeupHandler; +} + +static Bool +rfbScreenInit(index, pScreen, argc, argv) + int index; + ScreenPtr pScreen; + int argc; + char ** argv; +{ + rfbScreenInfoPtr prfb = &rfbScreen; + int dpix = 75, dpiy = 75; + int ret; + unsigned char *pbits; + VisualPtr vis; +#ifdef RENDER + PictureScreenPtr ps; +#endif + + if (VNCGeneration != serverGeneration) { + VncExtensionInit(); + VNCGeneration = serverGeneration; + } + + if (monitorResolution != 0) { + dpix = monitorResolution; + dpiy = monitorResolution; + } + + prfb->rfbAuthTries = 0; + prfb->rfbAuthTooManyTries = FALSE; + prfb->rfbUserAccept = FALSE; + prfb->udpSockConnected = FALSE; + prfb->timer = NULL; + prfb->httpListenSock = -1; + prfb->httpSock = -1; + prfb->rfbListenSock = -1; + prfb->rdpListenSock = -1; + prfb->paddedWidthInBytes = PixmapBytePad(prfb->width, prfb->depth); + prfb->bitsPerPixel = rfbBitsPerPixel(prfb->depth); + pbits = rfbAllocateFramebufferMemory(prfb); + if (!pbits) return FALSE; + + miClearVisualTypes(); + + if (defaultColorVisualClass == -1) + defaultColorVisualClass = TrueColor; + + if (!miSetVisualTypes(prfb->depth, miGetDefaultVisualMask(prfb->depth), 8, + defaultColorVisualClass) ) + return FALSE; + + miSetPixmapDepths(); + + switch (prfb->bitsPerPixel) + { + case 8: + ret = fbScreenInit(pScreen, pbits, prfb->width, prfb->height, + dpix, dpiy, prfb->paddedWidthInBytes, 8); + break; + case 16: + ret = fbScreenInit(pScreen, pbits, prfb->width, prfb->height, + dpix, dpiy, prfb->paddedWidthInBytes / 2, 16); + if (prfb->depth == 15) { + blueBits = 5; greenBits = 5; redBits = 5; + } else { + blueBits = 5; greenBits = 6; redBits = 5; + } + break; + case 32: + ret = fbScreenInit(pScreen, pbits, prfb->width, prfb->height, + dpix, dpiy, prfb->paddedWidthInBytes / 4, 32); + blueBits = 8; greenBits = 8; redBits = 8; + break; + default: + return FALSE; + } + + if (!ret) return FALSE; + + miInitializeBackingStore(pScreen); + + if (prfb->bitsPerPixel > 8) { + if (strcasecmp(primaryOrder, "bgr") == 0) { + rfbLog("BGR format %d %d %d\n", blueBits, greenBits, redBits); + vis = pScreen->visuals + pScreen->numVisuals; + while (--vis >= pScreen->visuals) { + if ((vis->class | DynamicClass) == DirectColor) { + vis->offsetRed = 0; + vis->redMask = (1 << redBits) - 1; + vis->offsetGreen = redBits; + vis->greenMask = ((1 << greenBits) - 1) << vis->offsetGreen; + vis->offsetBlue = redBits + greenBits; + vis->blueMask = ((1 << blueBits) - 1) << vis->offsetBlue; + } + } + } else { + rfbLog("RGB format %d %d %d\n", blueBits, greenBits, redBits); + vis = pScreen->visuals + pScreen->numVisuals; + while (--vis >= pScreen->visuals) { + if ((vis->class | DynamicClass) == DirectColor) { + vis->offsetBlue = 0; + vis->blueMask = (1 << blueBits) - 1; + vis->offsetGreen = blueBits; + vis->greenMask = ((1 << greenBits) - 1) << vis->offsetGreen; + vis->offsetRed = blueBits + greenBits; + vis->redMask = ((1 << redBits) - 1) << vis->offsetRed; + } + } + } + } + + if (prfb->bitsPerPixel > 4) + fbPictureInit(pScreen, 0, 0); + + if (!AllocateGCPrivate(pScreen, rfbGCIndex, sizeof(rfbGCRec))) { + FatalError("rfbScreenInit: AllocateGCPrivate failed\n"); + } + + prfb->cursorIsDrawn = FALSE; + prfb->dontSendFramebufferUpdate = FALSE; + + prfb->CloseScreen = pScreen->CloseScreen; + prfb->WakeupHandler = pScreen->WakeupHandler; + prfb->CreateGC = pScreen->CreateGC; + prfb->PaintWindowBackground = pScreen->PaintWindowBackground; + prfb->PaintWindowBorder = pScreen->PaintWindowBorder; + prfb->CopyWindow = pScreen->CopyWindow; + prfb->ClearToBackground = pScreen->ClearToBackground; + prfb->RestoreAreas = pScreen->RestoreAreas; +#ifdef CHROMIUM + prfb->RealizeWindow = pScreen->RealizeWindow; + prfb->UnrealizeWindow = pScreen->UnrealizeWindow; + prfb->DestroyWindow = pScreen->DestroyWindow; + prfb->PositionWindow = pScreen->PositionWindow; + prfb->ResizeWindow = pScreen->ResizeWindow; + prfb->ClipNotify = pScreen->ClipNotify; +#endif +#ifdef RENDER + ps = GetPictureScreenIfSet(pScreen); + if (ps) + prfb->Composite = ps->Composite; +#endif + pScreen->CloseScreen = rfbCloseScreen; + pScreen->WakeupHandler = rfbWakeupHandler; + pScreen->CreateGC = rfbCreateGC; + pScreen->PaintWindowBackground = rfbPaintWindowBackground; + pScreen->PaintWindowBorder = rfbPaintWindowBorder; + pScreen->CopyWindow = rfbCopyWindow; + pScreen->ClearToBackground = rfbClearToBackground; + pScreen->RestoreAreas = rfbRestoreAreas; +#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 + + pScreen->InstallColormap = rfbInstallColormap; + pScreen->UninstallColormap = rfbUninstallColormap; + pScreen->ListInstalledColormaps = rfbListInstalledColormaps; + pScreen->StoreColors = rfbStoreColors; + + pScreen->SaveScreen = (SaveScreenProcPtr)rfbAlwaysTrue; + + rfbDCInitialize(pScreen, &rfbPointerCursorFuncs); + + if (noCursor) { + pScreen->DisplayCursor = (DisplayCursorProcPtr)rfbAlwaysTrue; + prfb->cursorIsDrawn = TRUE; + } + + pScreen->blackPixel = prfb->blackPixel; + pScreen->whitePixel = prfb->whitePixel; + + prfb->rfbServerFormat.bitsPerPixel = prfb->bitsPerPixel; + prfb->rfbServerFormat.depth = prfb->depth; + prfb->rfbServerFormat.bigEndian = !(*(char *)&rfbEndianTest); + + /* Find the root visual and set the server format */ + for (vis = pScreen->visuals; vis->vid != pScreen->rootVisual; vis++) + ; + prfb->rfbServerFormat.trueColour = (vis->class == TrueColor); + + if ( (vis->class == TrueColor) || (vis->class == DirectColor) ) { + prfb->rfbServerFormat.redMax = vis->redMask >> vis->offsetRed; + prfb->rfbServerFormat.greenMax = vis->greenMask >> vis->offsetGreen; + prfb->rfbServerFormat.blueMax = vis->blueMask >> vis->offsetBlue; + prfb->rfbServerFormat.redShift = vis->offsetRed; + prfb->rfbServerFormat.greenShift = vis->offsetGreen; + prfb->rfbServerFormat.blueShift = vis->offsetBlue; + } else { + prfb->rfbServerFormat.redMax + = prfb->rfbServerFormat.greenMax + = prfb->rfbServerFormat.blueMax = 0; + prfb->rfbServerFormat.redShift + = prfb->rfbServerFormat.greenShift + = prfb->rfbServerFormat.blueShift = 0; + } + + ret = fbCreateDefColormap(pScreen); + + rfbInitSockets(pScreen); +#if 0 + rdpInitSockets(pScreen); +#endif + if (inetdSock == -1) + httpInitSockets(pScreen); + + return ret; + +} /* end rfbScreenInit */ + + + +/* + * InitInput is also called every time the server resets. It is called after + * InitOutput so we can assume that rfbInitSockets has already been called. + */ +void +InitInput(argc, argv) + int argc; + char *argv[]; +{ + DeviceIntPtr p, k; + k = AddInputDevice(rfbKeybdProc, TRUE); + p = AddInputDevice(rfbMouseProc, TRUE); + RegisterKeyboardDevice(k); + RegisterPointerDevice(p); + + mieqInit(); + +#if 0 + mieqCheckForInput[0] = checkForInput[0]; + mieqCheckForInput[1] = checkForInput[1]; + SetInputCheck(&alwaysCheckForInput[0], &alwaysCheckForInput[1]); +#endif +} + + +static int +rfbKeybdProc(pDevice, onoff) + DeviceIntPtr pDevice; + int onoff; +{ + KeySymsRec keySyms; + CARD8 modMap[MAP_LENGTH]; + DevicePtr pDev = (DevicePtr)pDevice; + + switch (onoff) + { + case DEVICE_INIT: + vncSetKeyboardDevice(pDevice); + KbdDeviceInit(pDevice, &keySyms, modMap); + InitKeyboardDeviceStruct(pDev, &keySyms, modMap, + (BellProcPtr)rfbSendBell, + (KbdCtrlProcPtr)NoopDDA); + break; + case DEVICE_ON: + pDev->on = TRUE; + KbdDeviceOn(); + break; + case DEVICE_OFF: + pDev->on = FALSE; + KbdDeviceOff(); + break; + case DEVICE_CLOSE: + if (pDev->on) + KbdDeviceOff(); + break; + } + return Success; +} + +static int +rfbMouseProc(pDevice, onoff) + DeviceIntPtr pDevice; + int onoff; +{ + BYTE map[6]; + DevicePtr pDev = (DevicePtr)pDevice; + + switch (onoff) + { + case DEVICE_INIT: + PtrDeviceInit(); + map[1] = 1; + map[2] = 2; + map[3] = 3; + map[4] = 4; + map[5] = 5; + InitPointerDeviceStruct(pDev, map, 5, + GetMotionHistory, + PtrDeviceControl, + GetMaximumEventsNum(), 2 /* numAxes */); + vncSetPointerDevice(pDevice); + break; + + case DEVICE_ON: + pDev->on = TRUE; + PtrDeviceOn(pDevice); + break; + + case DEVICE_OFF: + pDev->on = FALSE; + PtrDeviceOff(); + break; + + case DEVICE_CLOSE: + if (pDev->on) + PtrDeviceOff(); + break; + } + return Success; +} + + +Bool +LegalModifier(unsigned int key, DeviceIntPtr pDev) +{ + return TRUE; +} + + +void +ProcessInputEvents(void) +{ +#if 0 + if (*mieqCheckForInput[0] != *mieqCheckForInput[1]) { +#endif + mieqProcessInputEvents(); +#if 0 + } +#endif +} + + +static Bool CheckDisplayNumber(int n) +{ + char fname[32]; + int sock; + struct sockaddr_in addr; + + sock = socket(AF_INET, SOCK_STREAM, 0); + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_ANY); + addr.sin_port = htons(6000+n); + if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + close(sock); + return FALSE; + } + close(sock); + + sprintf(fname, "/tmp/.X%d-lock", n); + if (access(fname, F_OK) == 0) + return FALSE; + + sprintf(fname, "/tmp/.X11-unix/X%d", n); + if (access(fname, F_OK) == 0) + return FALSE; + + return TRUE; +} + +static Bool +rfbAlwaysTrue(void) +{ + return TRUE; +} + + +static unsigned char * +rfbAllocateFramebufferMemory(prfb) + rfbScreenInfoPtr prfb; +{ + if (prfb->pfbMemory) return prfb->pfbMemory; /* already done */ + + prfb->sizeInBytes = (prfb->paddedWidthInBytes * prfb->height); + + prfb->pfbMemory = (unsigned char *)Xalloc(prfb->sizeInBytes); + + return prfb->pfbMemory; +} + + +static Bool +rfbCursorOffScreen (ppScreen, x, y) + ScreenPtr *ppScreen; + int *x, *y; +{ + return FALSE; +} + +static void +rfbCrossScreen (pScreen, entering) + ScreenPtr pScreen; + Bool entering; +{ +} + +void +ddxGiveUp() +{ + Xfree(rfbScreen.pfbMemory); + if (initOutputCalled) { + char unixSocketName[32]; + sprintf(unixSocketName,"/tmp/.X11-unix/X%s",display); + unlink(unixSocketName); +#ifdef CORBA + shutdownCORBA(); +#endif + } +} + +void +AbortDDX() +{ + ddxGiveUp(); +} + +void +OsVendorInit() +{ +} + +void +OsVendorFatalError() +{ +} + +#ifdef DDXTIME /* from ServerOSDefines */ +CARD32 +GetTimeInMillis() +{ + struct timeval tp; + + X_GETTIMEOFDAY(&tp); + return(tp.tv_sec * 1000) + (tp.tv_usec / 1000); +} +#endif + +void +ddxUseMsg() +{ + ErrorF("-geometry WxH set framebuffer width & height\n"); + ErrorF("-depth D set framebuffer depth\n"); + ErrorF("-pixelformat format set pixel format (BGRnnn or RGBnnn)\n"); + ErrorF("-udpinputport port UDP port for keyboard/pointer data\n"); + ErrorF("-rfbport port TCP port for RFB protocol\n"); + ErrorF("-rfbwait time max time in ms to wait for RFB client\n"); + ErrorF("-nocursor don't put up a cursor\n"); + ErrorF("-rfbauth passwd-file use authentication on RFB protocol\n"); + ErrorF("-loginauth use login-style Unix authentication\n"); + ErrorF("-httpd dir serve files via HTTP from here\n"); + ErrorF("-httpport port port for HTTP\n"); + ErrorF("-deferupdate time time in ms to defer updates " + "(default 40)\n"); + ErrorF("-economictranslate less memory-hungry translation\n"); + ErrorF("-lazytight disable \"gradient\" filter in tight " + "encoding\n"); + ErrorF("-desktop name VNC desktop name (default x11)\n"); + ErrorF("-alwaysshared always treat new clients as shared\n"); + ErrorF("-nevershared never treat new clients as shared\n"); + ErrorF("-dontdisconnect don't disconnect existing clients when a " + "new non-shared\n" + " connection comes in (refuse new connection " + "instead)\n"); + ErrorF("-localhost only allow connections from localhost\n" + " to the vnc ports. Use -nolisten tcp to disable\n" + " remote X clients as well.\n"); + ErrorF("-viewonly let clients only view the desktop\n"); + ErrorF("-interface ipaddr only bind to specified interface " + "address\n"); + ErrorF("-inetd Xvnc is launched by inetd\n"); + exit(1); +} + + +void ddxInitGlobals(void) +{ + /* dummy function called by InitGlobals in os/utils.c */ +} + + +/* + * 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); +} diff -pNur xorg-server-1.4.orig/hw/vnc/kbdptr.c xorg-server-1.4/hw/vnc/kbdptr.c --- xorg-server-1.4.orig/hw/vnc/kbdptr.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/kbdptr.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,458 @@ +/* + * kbdptr.c - deal with keyboard and pointer device over TCP & UDP. + * + * 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 "rfb.h" +#include "X11/X.h" +#define NEED_EVENTS +#include "X11/Xproto.h" +#include "inputstr.h" +#define XK_CYRILLIC +#include <X11/keysym.h> +#include <X11/Xatom.h> +#include "mi.h" +#include "mipointer.h" +#include "keyboard.h" + +#ifdef DMXVNC +#include "dmxinput.h" +#endif + +#define KEY_IS_PRESSED(keycode) \ + (kbdDevice->key->down[(keycode) >> 3] & (1 << ((keycode) & 7))) + +static void vncXConvertCase(KeySym sym, KeySym *lower, KeySym *upper); + +static DeviceIntPtr ptrDevice = NULL, kbdDevice = NULL; + + +void +vncSetKeyboardDevice(DeviceIntPtr kbd) +{ + if (kbdDevice && kbd) + return; /* set once */ + kbdDevice = kbd; +} + + +void +vncSetPointerDevice(DeviceIntPtr ptr) +{ + if (ptrDevice && ptr) + return; /* set once */ + ptrDevice = ptr; +} + + +#ifndef DMXVNC +static void +EnqueueMotion(DeviceIntPtr ptrDev, int x, int y) +{ + xEvent *events = (xEvent*) calloc(sizeof(xEvent), GetMaximumEventsNum()); + int detail = 0, valuators[2], nevents, i; + valuators[0] = x; + valuators[1] = y; + if (!ptrDev) { + ErrorF("VNC: In EnqueueMotion() ptrDev=NULL\n"); + return; + } + nevents = GetPointerEvents(events, ptrDev, MotionNotify, detail, + POINTER_ABSOLUTE, 0, 2, valuators); + for (i = 0; i < nevents; i++) + mieqEnqueue(ptrDev, events + i); + free(events); +} +#endif + + +static void +EnqueueButton(DeviceIntPtr ptrDev, int type, int detail) +{ + xEvent *events = (xEvent*) calloc(sizeof(xEvent), GetMaximumEventsNum()); + int nevents, i; + if (!ptrDev) { + ErrorF("VNC: In EnqueueButton() ptrDev=NULL\n"); + return; + } + nevents = GetPointerEvents(events, ptrDev, type, detail, + POINTER_ABSOLUTE, 0, 0, NULL/*valuators*/); + for (i = 0; i < nevents; i++) + mieqEnqueue(ptrDev, events + i); + free(events); +} + + +static void +EnqueueKey(DeviceIntPtr kbdDev, int type, int detail) +{ + xEvent *events = (xEvent*) calloc(sizeof(xEvent), GetMaximumEventsNum()); + int nevents, i; + if (!kbdDev) { + ErrorF("VNC: In EnqueueKey() kbdDev=NULL\n"); + return; + } + nevents = GetKeyboardEvents(events, kbdDev, type, detail); + for (i = 0; i < nevents; i++) + mieqEnqueue(kbdDev, events + i); + free(events); +} + + +/* + * Called when the rfbserver receives a rfbKeyEvent event from a client. + * Put an X keyboard event into the event queue. + */ +void +KbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl) +{ + const int type = down ? KeyPress : KeyRelease; + KeySymsPtr keySyms; + int i; + int keyCode = 0; + int freeIndex = -1; + Bool fakeShiftPress = FALSE; + Bool fakeShiftLRelease = FALSE; + Bool fakeShiftRRelease = FALSE; + Bool shiftMustBeReleased = FALSE; + Bool shiftMustBePressed = FALSE; + + if (!kbdDevice) + return; + + keySyms = &kbdDevice->key->curKeySyms; + +#ifdef CORBA + if (cl) { + CARD32 clientId = cl->sock; + ChangeWindowProperty(WindowTable[0], VNC_LAST_CLIENT_ID, XA_INTEGER, + 32, PropModeReplace, 1, (pointer)&clientId, TRUE); + } +#endif + + /* NOTE: This is where it gets hairy for XFree86 servers. + * I think the best way to deal with this is invent a new protocol + * to send over the wire the remote keyboard type and correctly + * handle that as XINPUT extension device (we're part of the way + * there for that. + * + * Alan. + */ +#if !XFREE86VNC + /* First check if it's one of our predefined keys. If so then we can make + some attempt at allowing an xmodmap inside a VNC desktop behave + something like you'd expect - e.g. if keys A & B are swapped over and + the VNC client sends an A, then map it to a B when generating the X + event. We don't attempt to do this for keycodes which we make up on the + fly because it's too hard... */ + + for (i = 0; i < N_PREDEFINED_KEYS * GLYPHS_PER_KEY; i++) { + if (keySym == map[i]) { + keyCode = MIN_KEY_CODE + i / GLYPHS_PER_KEY; + + if (map[(i/GLYPHS_PER_KEY) * GLYPHS_PER_KEY + 1] != NoSymbol) { + + /* this keycode has more than one symbol associated with it, + so shift state is important */ + + if ((i % GLYPHS_PER_KEY) == 0) + shiftMustBeReleased = TRUE; + else + shiftMustBePressed = TRUE; + } + break; + } + } +#endif + + if (!keyCode) { + + /* not one of our predefined keys - see if it's in the current keyboard + mapping (i.e. we've already allocated an extra keycode for it) */ + + if (keySyms->mapWidth < 2) { + ErrorF("KbdAddEvent: Sanity check failed - Keyboard mapping has " + "less than 2 keysyms per keycode (KeySym 0x%x)\n", (int)keySym); + return; + } + + for (i = 0; i < NO_OF_KEYS * keySyms->mapWidth; i++) { + if (keySym == keySyms->map[i]) { + keyCode = MIN_KEY_CODE + i / keySyms->mapWidth; + + if (keySyms->map[(i / keySyms->mapWidth) + * keySyms->mapWidth + 1] != NoSymbol) { + + /* this keycode has more than one symbol associated with + it, so shift state is important */ + + if ((i % keySyms->mapWidth) == 0) + shiftMustBeReleased = TRUE; + else + shiftMustBePressed = TRUE; + } + break; + } + if ((freeIndex == -1) && (keySyms->map[i] == NoSymbol) + && (i % keySyms->mapWidth) == 0) + { + freeIndex = i; + } + } + } + + if (!keyCode) { + KeySym lower, upper; + + /* we don't have an existing keycode - make one up on the fly and add + it to the keyboard mapping. Thanks to Vlad Harchev for pointing + out problems with non-ascii capitalisation. */ + + if (freeIndex == -1) { + ErrorF("KbdAddEvent: ignoring KeySym 0x%x - no free KeyCodes\n", + (int)keySym); + return; + } + + keyCode = MIN_KEY_CODE + freeIndex / keySyms->mapWidth; + + vncXConvertCase(keySym, &lower, &upper); + + if (lower == upper) { + keySyms->map[freeIndex] = keySym; + + } else { + keySyms->map[freeIndex] = lower; + keySyms->map[freeIndex+1] = upper; + + if (keySym == lower) + shiftMustBeReleased = TRUE; + else + shiftMustBePressed = TRUE; + } + + SendMappingNotify(MappingKeyboard, keyCode, 1, serverClient); + + ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n", + (int)keySym, keyCode); + } + + if (down) { + if (shiftMustBePressed && !(kbdDevice->key->state & ShiftMask)) { + fakeShiftPress = TRUE; + EnqueueKey(kbdDevice, KeyPress, SHIFT_L_KEY_CODE); + } + if (shiftMustBeReleased && (kbdDevice->key->state & ShiftMask)) { + if (KEY_IS_PRESSED(SHIFT_L_KEY_CODE)) { + fakeShiftLRelease = TRUE; + EnqueueKey(kbdDevice, KeyRelease, SHIFT_L_KEY_CODE); + } + if (KEY_IS_PRESSED(SHIFT_R_KEY_CODE)) { + fakeShiftRRelease = TRUE; + EnqueueKey(kbdDevice, KeyRelease, SHIFT_R_KEY_CODE); + } + } + } + + EnqueueKey(kbdDevice, type, keyCode); + + if (fakeShiftPress) { + EnqueueKey(kbdDevice, KeyRelease, SHIFT_L_KEY_CODE); + } + if (fakeShiftLRelease) { + EnqueueKey(kbdDevice, KeyPress, SHIFT_L_KEY_CODE); + } + if (fakeShiftRRelease) { + EnqueueKey(kbdDevice, KeyPress, SHIFT_R_KEY_CODE); + } +} + + +/* + * Called when the rfbserver receives a rfbPointerEvent event from a client. + * Put an X mouse event into the event queue. + */ +void +PtrAddEvent(int buttonMask, int x, int y, rfbClientPtr cl) +{ + int i; + static int oldButtonMask = 0; + +#ifdef CORBA + if (cl) { + CARD32 clientId = cl->sock; + ChangeWindowProperty(WindowTable[0], VNC_LAST_CLIENT_ID, XA_INTEGER, + 32, PropModeReplace, 1, (pointer)&clientId, TRUE); + } +#endif + +#ifdef DMXVNC + dmxCoreMotion(&ptrDevice->public, x, y, 0, DMX_BLOCK); +#else + EnqueueMotion(ptrDevice, x, y ); +#endif + + for (i = 0; i < 5; i++) { + if ((buttonMask ^ oldButtonMask) & (1<<i)) { + int type, detail; + if (buttonMask & (1<<i)) { + type = ButtonPress; + detail = i + 1; + } else { + type = ButtonRelease; + detail = i + 1; + } + EnqueueButton(ptrDevice, type, detail); + } + } + + oldButtonMask = buttonMask; +} + +void +KbdReleaseAllKeys(void) +{ + int i, j; + + if (!kbdDevice) + return; + + for (i = 0; i < DOWN_LENGTH; i++) { + if (kbdDevice->key->down[i] != 0) { + for (j = 0; j < 8; j++) { + if (kbdDevice->key->down[i] & (1 << j)) { + int detail = (i << 3) | j; + EnqueueKey(kbdDevice, KeyRelease, detail); + } + } + } + } +} + + +/* copied from Xlib source */ + +static void vncXConvertCase(KeySym sym, KeySym *lower, KeySym *upper) +{ + *lower = sym; + *upper = sym; + switch(sym >> 8) { + case 0: /* Latin 1 */ + if ((sym >= XK_A) && (sym <= XK_Z)) + *lower += (XK_a - XK_A); + else if ((sym >= XK_a) && (sym <= XK_z)) + *upper -= (XK_a - XK_A); + else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) + *lower += (XK_agrave - XK_Agrave); + else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) + *upper -= (XK_agrave - XK_Agrave); + else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) + *lower += (XK_oslash - XK_Ooblique); + else if ((sym >= XK_oslash) && (sym <= XK_thorn)) + *upper -= (XK_oslash - XK_Ooblique); + break; + case 1: /* Latin 2 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym == XK_Aogonek) + *lower = XK_aogonek; + else if (sym >= XK_Lstroke && sym <= XK_Sacute) + *lower += (XK_lstroke - XK_Lstroke); + else if (sym >= XK_Scaron && sym <= XK_Zacute) + *lower += (XK_scaron - XK_Scaron); + else if (sym >= XK_Zcaron && sym <= XK_Zabovedot) + *lower += (XK_zcaron - XK_Zcaron); + else if (sym == XK_aogonek) + *upper = XK_Aogonek; + else if (sym >= XK_lstroke && sym <= XK_sacute) + *upper -= (XK_lstroke - XK_Lstroke); + else if (sym >= XK_scaron && sym <= XK_zacute) + *upper -= (XK_scaron - XK_Scaron); + else if (sym >= XK_zcaron && sym <= XK_zabovedot) + *upper -= (XK_zcaron - XK_Zcaron); + else if (sym >= XK_Racute && sym <= XK_Tcedilla) + *lower += (XK_racute - XK_Racute); + else if (sym >= XK_racute && sym <= XK_tcedilla) + *upper -= (XK_racute - XK_Racute); + break; + case 2: /* Latin 3 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Hstroke && sym <= XK_Hcircumflex) + *lower += (XK_hstroke - XK_Hstroke); + else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex) + *lower += (XK_gbreve - XK_Gbreve); + else if (sym >= XK_hstroke && sym <= XK_hcircumflex) + *upper -= (XK_hstroke - XK_Hstroke); + else if (sym >= XK_gbreve && sym <= XK_jcircumflex) + *upper -= (XK_gbreve - XK_Gbreve); + else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex) + *lower += (XK_cabovedot - XK_Cabovedot); + else if (sym >= XK_cabovedot && sym <= XK_scircumflex) + *upper -= (XK_cabovedot - XK_Cabovedot); + break; + case 3: /* Latin 4 */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Rcedilla && sym <= XK_Tslash) + *lower += (XK_rcedilla - XK_Rcedilla); + else if (sym >= XK_rcedilla && sym <= XK_tslash) + *upper -= (XK_rcedilla - XK_Rcedilla); + else if (sym == XK_ENG) + *lower = XK_eng; + else if (sym == XK_eng) + *upper = XK_ENG; + else if (sym >= XK_Amacron && sym <= XK_Umacron) + *lower += (XK_amacron - XK_Amacron); + else if (sym >= XK_amacron && sym <= XK_umacron) + *upper -= (XK_amacron - XK_Amacron); + break; + case 6: /* Cyrillic */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE) + *lower -= (XK_Serbian_DJE - XK_Serbian_dje); + else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze) + *upper += (XK_Serbian_DJE - XK_Serbian_dje); + else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN) + *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu); + else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign) + *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu); + break; + case 7: /* Greek */ + /* Assume the KeySym is a legal value (ignore discontinuities) */ + if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent) + *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent); + else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent && + sym != XK_Greek_iotaaccentdieresis && + sym != XK_Greek_upsilonaccentdieresis) + *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent); + else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA) + *lower += (XK_Greek_alpha - XK_Greek_ALPHA); + else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega && + sym != XK_Greek_finalsmallsigma) + *upper -= (XK_Greek_alpha - XK_Greek_ALPHA); + break; + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/keyboard.h xorg-server-1.4/hw/vnc/keyboard.h --- xorg-server-1.4.orig/hw/vnc/keyboard.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/keyboard.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,167 @@ +/* + * 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> + */ + +#define MIN_KEY_CODE 8 +#define MAX_KEY_CODE 255 +#define NO_OF_KEYS (MAX_KEY_CODE - MIN_KEY_CODE + 1) +#define GLYPHS_PER_KEY 4 + +#define CONTROL_L_KEY_CODE (MIN_KEY_CODE + 29) +#define CONTROL_R_KEY_CODE (MIN_KEY_CODE + 101) +#define SHIFT_L_KEY_CODE (MIN_KEY_CODE + 42) +#define SHIFT_R_KEY_CODE (MIN_KEY_CODE + 54) +#define META_L_KEY_CODE (MIN_KEY_CODE + 107) +#define META_R_KEY_CODE (MIN_KEY_CODE + 108) +#define ALT_L_KEY_CODE (MIN_KEY_CODE + 56) +#define ALT_R_KEY_CODE (MIN_KEY_CODE + 105) + +static KeySym map[MAX_KEY_CODE * GLYPHS_PER_KEY] = { + /* 0x00 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x01 */ XK_Escape, NoSymbol, NoSymbol, NoSymbol, + /* 0x02 */ XK_1, XK_exclam, NoSymbol, NoSymbol, + /* 0x03 */ XK_2, XK_at, NoSymbol, NoSymbol, + /* 0x04 */ XK_3, XK_numbersign, NoSymbol, NoSymbol, + /* 0x05 */ XK_4, XK_dollar, NoSymbol, NoSymbol, + /* 0x06 */ XK_5, XK_percent, NoSymbol, NoSymbol, + /* 0x07 */ XK_6, XK_asciicircum, NoSymbol, NoSymbol, + /* 0x08 */ XK_7, XK_ampersand, NoSymbol, NoSymbol, + /* 0x09 */ XK_8, XK_asterisk, NoSymbol, NoSymbol, + /* 0x0a */ XK_9, XK_parenleft, NoSymbol, NoSymbol, + /* 0x0b */ XK_0, XK_parenright, NoSymbol, NoSymbol, + /* 0x0c */ XK_minus, XK_underscore, NoSymbol, NoSymbol, + /* 0x0d */ XK_equal, XK_plus, NoSymbol, NoSymbol, + /* 0x0e */ XK_BackSpace, NoSymbol, NoSymbol, NoSymbol, + /* 0x0f */ XK_Tab, XK_ISO_Left_Tab,NoSymbol, NoSymbol, + /* 0x10 */ XK_q, XK_Q, NoSymbol, NoSymbol, + /* 0x11 */ XK_w, XK_W, NoSymbol, NoSymbol, + /* 0x12 */ XK_e, XK_E, NoSymbol, NoSymbol, + /* 0x13 */ XK_r, XK_R, NoSymbol, NoSymbol, + /* 0x14 */ XK_t, XK_T, NoSymbol, NoSymbol, + /* 0x15 */ XK_y, XK_Y, NoSymbol, NoSymbol, + /* 0x16 */ XK_u, XK_U, NoSymbol, NoSymbol, + /* 0x17 */ XK_i, XK_I, NoSymbol, NoSymbol, + /* 0x18 */ XK_o, XK_O, NoSymbol, NoSymbol, + /* 0x19 */ XK_p, XK_P, NoSymbol, NoSymbol, + /* 0x1a */ XK_bracketleft, XK_braceleft, NoSymbol, NoSymbol, + /* 0x1b */ XK_bracketright,XK_braceright, NoSymbol, NoSymbol, + /* 0x1c */ XK_Return, NoSymbol, NoSymbol, NoSymbol, + /* 0x1d */ XK_Control_L, NoSymbol, NoSymbol, NoSymbol, + /* 0x1e */ XK_a, XK_A, NoSymbol, NoSymbol, + /* 0x1f */ XK_s, XK_S, NoSymbol, NoSymbol, + /* 0x20 */ XK_d, XK_D, NoSymbol, NoSymbol, + /* 0x21 */ XK_f, XK_F, NoSymbol, NoSymbol, + /* 0x22 */ XK_g, XK_G, NoSymbol, NoSymbol, + /* 0x23 */ XK_h, XK_H, NoSymbol, NoSymbol, + /* 0x24 */ XK_j, XK_J, NoSymbol, NoSymbol, + /* 0x25 */ XK_k, XK_K, NoSymbol, NoSymbol, + /* 0x26 */ XK_l, XK_L, NoSymbol, NoSymbol, + /* 0x27 */ XK_semicolon, XK_colon, NoSymbol, NoSymbol, + /* 0x28 */ XK_quoteright, XK_quotedbl, NoSymbol, NoSymbol, + /* 0x29 */ XK_quoteleft, XK_asciitilde, NoSymbol, NoSymbol, + /* 0x2a */ XK_Shift_L, NoSymbol, NoSymbol, NoSymbol, + /* 0x2b */ XK_backslash, XK_bar, NoSymbol, NoSymbol, + /* 0x2c */ XK_z, XK_Z, NoSymbol, NoSymbol, + /* 0x2d */ XK_x, XK_X, NoSymbol, NoSymbol, + /* 0x2e */ XK_c, XK_C, NoSymbol, NoSymbol, + /* 0x2f */ XK_v, XK_V, NoSymbol, NoSymbol, + /* 0x30 */ XK_b, XK_B, NoSymbol, NoSymbol, + /* 0x31 */ XK_n, XK_N, NoSymbol, NoSymbol, + /* 0x32 */ XK_m, XK_M, NoSymbol, NoSymbol, + /* 0x33 */ XK_comma, XK_less, NoSymbol, NoSymbol, + /* 0x34 */ XK_period, XK_greater, NoSymbol, NoSymbol, + /* 0x35 */ XK_slash, XK_question, NoSymbol, NoSymbol, + /* 0x36 */ XK_Shift_R, NoSymbol, NoSymbol, NoSymbol, + /* 0x37 */ XK_KP_Multiply, NoSymbol, NoSymbol, NoSymbol, + /* 0x38 */ XK_Alt_L, XK_Meta_L, NoSymbol, NoSymbol, + /* 0x39 */ XK_space, NoSymbol, NoSymbol, NoSymbol, + /* 0x3a */ XK_Caps_Lock, NoSymbol, NoSymbol, NoSymbol, + /* 0x3b */ XK_F1, NoSymbol, NoSymbol, NoSymbol, + /* 0x3c */ XK_F2, NoSymbol, NoSymbol, NoSymbol, + /* 0x3d */ XK_F3, NoSymbol, NoSymbol, NoSymbol, + /* 0x3e */ XK_F4, NoSymbol, NoSymbol, NoSymbol, + /* 0x3f */ XK_F5, NoSymbol, NoSymbol, NoSymbol, + /* 0x40 */ XK_F6, NoSymbol, NoSymbol, NoSymbol, + /* 0x41 */ XK_F7, NoSymbol, NoSymbol, NoSymbol, + /* 0x42 */ XK_F8, NoSymbol, NoSymbol, NoSymbol, + /* 0x43 */ XK_F9, NoSymbol, NoSymbol, NoSymbol, + /* 0x44 */ XK_F10, NoSymbol, NoSymbol, NoSymbol, + /* 0x45 */ XK_Num_Lock, NoSymbol, NoSymbol, NoSymbol, + /* 0x46 */ XK_Scroll_Lock, NoSymbol, NoSymbol, NoSymbol, + /* 0x47 */ XK_KP_Home, XK_KP_7, NoSymbol, NoSymbol, + /* 0x48 */ XK_KP_Up, XK_KP_8, NoSymbol, NoSymbol, + /* 0x49 */ XK_KP_Prior, XK_KP_9, NoSymbol, NoSymbol, + /* 0x4a */ XK_KP_Subtract, NoSymbol, NoSymbol, NoSymbol, + /* 0x4b */ XK_KP_Left, XK_KP_4, NoSymbol, NoSymbol, + /* 0x4c */ XK_KP_Begin, XK_KP_5, NoSymbol, NoSymbol, + /* 0x4d */ XK_KP_Right, XK_KP_6, NoSymbol, NoSymbol, + /* 0x4e */ XK_KP_Add, NoSymbol, NoSymbol, NoSymbol, + /* 0x4f */ XK_KP_End, XK_KP_1, NoSymbol, NoSymbol, + /* 0x50 */ XK_KP_Down, XK_KP_2, NoSymbol, NoSymbol, + /* 0x51 */ XK_KP_Next, XK_KP_3, NoSymbol, NoSymbol, + /* 0x52 */ XK_KP_Insert, XK_KP_0, NoSymbol, NoSymbol, + /* 0x53 */ XK_KP_Delete, XK_KP_Decimal, NoSymbol, NoSymbol, + /* 0x54 */ XK_Sys_Req, NoSymbol, NoSymbol, NoSymbol, + /* 0x55 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x56 */ XK_less, XK_greater, NoSymbol, NoSymbol, + /* 0x57 */ XK_F11, NoSymbol, NoSymbol, NoSymbol, + /* 0x58 */ XK_F12, NoSymbol, NoSymbol, NoSymbol, + /* 0x59 */ XK_Home, NoSymbol, NoSymbol, NoSymbol, + /* 0x5a */ XK_Up, NoSymbol, NoSymbol, NoSymbol, + /* 0x5b */ XK_Prior, NoSymbol, NoSymbol, NoSymbol, + /* 0x5c */ XK_Left, NoSymbol, NoSymbol, NoSymbol, + /* 0x5d */ XK_Begin, NoSymbol, NoSymbol, NoSymbol, + /* 0x5e */ XK_Right, NoSymbol, NoSymbol, NoSymbol, + /* 0x5f */ XK_End, NoSymbol, NoSymbol, NoSymbol, + /* 0x60 */ XK_Down, NoSymbol, NoSymbol, NoSymbol, + /* 0x61 */ XK_Next, NoSymbol, NoSymbol, NoSymbol, + /* 0x62 */ XK_Insert, NoSymbol, NoSymbol, NoSymbol, + /* 0x63 */ XK_Delete, NoSymbol, NoSymbol, NoSymbol, + /* 0x64 */ XK_KP_Enter, NoSymbol, NoSymbol, NoSymbol, + /* 0x65 */ XK_Control_R, NoSymbol, NoSymbol, NoSymbol, + /* 0x66 */ XK_Pause, NoSymbol, NoSymbol, NoSymbol, + /* 0x67 */ XK_Print, NoSymbol, NoSymbol, NoSymbol, + /* 0x68 */ XK_KP_Divide, NoSymbol, NoSymbol, NoSymbol, + /* 0x69 */ XK_Alt_R, XK_Meta_R, NoSymbol, NoSymbol, + /* 0x6a */ XK_Break, NoSymbol, NoSymbol, NoSymbol, + /* 0x6b */ XK_Meta_L, NoSymbol, NoSymbol, NoSymbol, + /* 0x6c */ XK_Meta_R, NoSymbol, NoSymbol, NoSymbol, + /* 0x6d */ XK_Menu, NoSymbol, NoSymbol, NoSymbol, + /* 0x6e */ XK_F13, NoSymbol, NoSymbol, NoSymbol, + /* 0x6f */ XK_F14, NoSymbol, NoSymbol, NoSymbol, + /* 0x70 */ XK_F15, NoSymbol, NoSymbol, NoSymbol, + /* 0x71 */ XK_F16, NoSymbol, NoSymbol, NoSymbol, + /* 0x72 */ XK_F17, NoSymbol, NoSymbol, NoSymbol, + /* 0x73 */ XK_backslash, XK_underscore, NoSymbol, NoSymbol, + /* 0x74 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x75 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x76 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x77 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x78 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x79 */ XK_Henkan, XK_Mode_switch, NoSymbol, NoSymbol, + /* 0x7a */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x7b */ XK_Muhenkan, NoSymbol, NoSymbol, NoSymbol, + /* 0x7c */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x7d */ XK_backslash, XK_bar, NoSymbol, NoSymbol, + /* 0x7e */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, + /* 0x7f */ NoSymbol, NoSymbol, NoSymbol, NoSymbol, +}; + +#define N_PREDEFINED_KEYS (sizeof(map) / (sizeof(KeySym) * GLYPHS_PER_KEY)) diff -pNur xorg-server-1.4.orig/hw/vnc/LICENCE.TXT xorg-server-1.4/hw/vnc/LICENCE.TXT --- xorg-server-1.4.orig/hw/vnc/LICENCE.TXT 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/LICENCE.TXT 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) 19yy <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff -pNur xorg-server-1.4.orig/hw/vnc/loginauth.c xorg-server-1.4/hw/vnc/loginauth.c --- xorg-server-1.4.orig/hw/vnc/loginauth.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/loginauth.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,143 @@ +/* + * loginauth.c - deal with login-style Unix authentication. + * + * This file implements the UnixLogin authentication protocol when setting up + * an RFB connection. + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2003 Constantin Kaplinsky. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#ifdef linux +#include "/usr/include/shadow.h" +#endif +#include <stdio.h> +#include <stdlib.h> +#define _XOPEN_SOURCE +#include <unistd.h> +#include <pwd.h> +#include <sys/types.h> +#include "rfb.h" + +void rfbLoginAuthProcessClientMessage(rfbClientPtr cl) +{ + int n1 = 0, n2 = 0; + CARD32 loginLen, passwdLen, authResult; + char *loginBuf, *passwdBuf; + struct passwd *ps; + char *encPasswd1, *encPasswd2; + Bool ok; + + if ((n1 = ReadExact(cl->sock, (char *)&loginLen, + sizeof(loginLen))) <= 0 || + (n2 = ReadExact(cl->sock, (char *)&passwdLen, + sizeof(passwdLen))) <= 0) { + if (n1 != 0 || n2 != 0) + rfbLogPerror("rfbLoginAuthProcessClientMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + loginLen = Swap32IfLE(loginLen); + passwdLen = Swap32IfLE(passwdLen); + loginBuf = (char *)xalloc(loginLen + 1); + passwdBuf = (char *)xalloc(passwdLen + 1); + + n1 = n2 = 0; + if ((n1 = ReadExact(cl->sock, loginBuf, loginLen)) <= 0 || + (n2 = ReadExact(cl->sock, passwdBuf, passwdLen)) <= 0) { + if (n1 != 0 || n2 != 0) + rfbLogPerror("rfbLoginAuthProcessClientMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + loginBuf[loginLen] = '\0'; + passwdBuf[passwdLen] = '\0'; + + encPasswd1 = encPasswd2 = NULL; + + ps = getpwnam(loginBuf); + if (ps == NULL) { + rfbLog("rfbLoginAuthProcessClientMessage: " + "Cannot get password file entry for \"%s\"\n", loginBuf); + } else { + encPasswd1 = ps->pw_passwd; +#ifdef linux + if (strlen(ps->pw_passwd) == 1) { + struct spwd *sps; + + sps = getspnam(loginBuf); + if (sps == NULL) { + rfbLog("rfbLoginAuthProcessClientMessage:" + " getspnam() failed for user \"%s\"\n", loginBuf); + } else { + encPasswd1 = sps->sp_pwdp; + } + } +#endif + encPasswd2 = (char *)crypt(passwdBuf, encPasswd1); + memset(passwdBuf, 0, strlen(passwdBuf)); + } + + ok = FALSE; + if (encPasswd1 != NULL && encPasswd2 != NULL) { + if (strcmp(encPasswd1, encPasswd2) == 0) + ok = TRUE; + } + + if (!ok) { + rfbLog("rfbAuthProcessClientMessage: authentication failed from %s\n", + cl->host); + + if (rfbAuthConsiderBlocking(cl)) { + authResult = Swap32IfLE(rfbVncAuthTooMany); + } else { + authResult = Swap32IfLE(rfbVncAuthFailed); + } + + if (WriteExact(cl->sock, (char *)&authResult, + sizeof(authResult)) < 0) { + rfbLogPerror("rfbLoginAuthProcessClientMessage: write"); + } + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + rfbAuthUnblock(cl); + + cl->login = strdup(loginBuf); + rfbLog("Login-style authentication passed for user %s at %s\n", + cl->login, cl->host); + + authResult = Swap32IfLE(rfbVncAuthOK); + + if (WriteExact(cl->sock, (char *)&authResult, sizeof(authResult)) < 0) { + rfbLogPerror("rfbLoginAuthProcessClientMessage: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + cl->state = RFB_INITIALISATION; +} + diff -pNur xorg-server-1.4.orig/hw/vnc/Makefile.am xorg-server-1.4/hw/vnc/Makefile.am --- xorg-server-1.4.orig/hw/vnc/Makefile.am 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/Makefile.am 2007-09-06 16:09:51.000000000 -0700 @@ -0,0 +1,54 @@ +# XXX This Makefile.am probably needs some work. + +bin_PROGRAMS = Xvnc + +Xvnc_SOURCES = \ + $(top_srcdir)/fb/fbcmap_mi.c \ + $(top_srcdir)/Xi/stubs.c \ + $(top_srcdir)/mi/miinitext.c \ + auth.c \ + cmap.c \ + corre.c \ + cursor.c \ + cutpaste.c \ + d3des.c \ + dispcur.c \ + dpmsstubs.c \ + draw.c \ + hextile.c \ + httpd.c \ + init.c \ + kbdptr.c \ + loginauth.c \ + rfbkeyb.c \ + rfbmouse.c \ + rfbserver.c \ + rre.c \ + sprite.c \ + sockets.c \ + stats.c \ + tight.c \ + translate.c \ + vncauth.c \ + vncext.c \ + zlib.c + + +JPEG_LIBS = -ljpeg +CRYPT_LIBS = -lcrypt +FB_LIBS = ../../fb/.libs/libfb.a + +AM_CFLAGS = $(DIX_CFLAGS) $(XVNC_CFLAGS) -I$(top_srcdir)/hw/dmx/vnc -DCHROMIUM=1 + +Xvnc_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG) +Xvnc_LDADD = \ + $(XORG_CORE_LIBS) \ + $(XVNC_LIBS) \ + $(JPEG_LIBS) \ + $(CRYPT_LIBS) \ + $(VNCMODULES_LIBS) \ + $(XSERVER_LIBS) + + +relink: + rm -f Xvnc && $(MAKE) Xvnc diff -pNur xorg-server-1.4.orig/hw/vnc/rdp.c xorg-server-1.4/hw/vnc/rdp.c --- xorg-server-1.4.orig/hw/vnc/rdp.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rdp.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2004 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. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include <sys/types.h> +#include <sys/socket.h> +#include <fcntl.h> +#include <errno.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include "rfb.h" + +typedef struct rdpClientRec { + ScreenPtr pScreen; +} rdpClientRec, *rdpClientPtr; + +typedef struct rdpInRec { + char version; + char pad; + short length; + char hdrlen; + unsigned char pdu; +} rdpInRec, *rdpInPtr; + +static void +rdpCloseSock(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + close(pVNC->rdpListenSock); + RemoveEnabledDevice(pVNC->rdpListenSock); + pVNC->rdpListenSock = -1; +} + +/* + * rdpNewClient is called when a new connection has been made by whatever + * means. + */ + +static rdpClientPtr +rdpNewClient(ScreenPtr pScreen, int sock) +{ + rdpInRec in; + rdpClientPtr cl; + BoxRec box; + struct sockaddr_in addr; + SOCKLEN_T addrlen = sizeof(struct sockaddr_in); + VNCSCREENPTR(pScreen); + int i; + + cl = (rdpClientPtr)xalloc(sizeof(rdpClientRec)); + + cl->pScreen = pScreen; + + in.version = 3; + in.pad = 0; + in.length = 0x600; /* big endian */ + in.hdrlen = 0x00; + in.pdu = 0xCC; + + if (WriteExact(sock, (char *)&in, sizeof(rdpInRec)) < 0) { + rfbLogPerror("rfbNewClient: write"); + rdpCloseSock(pScreen); + return NULL; + } + + return cl; +} +/* + * rdpCheckFds is called from ProcessInputEvents to check for input on the + * HTTP socket(s). If there is input to process, rdpProcessInput is called. + */ + +void +rdpCheckFds(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + int nfds; + fd_set fds; + struct timeval tv; + struct sockaddr_in addr; + int sock; + const int one =1; + SOCKLEN_T addrlen = sizeof(addr); + + FD_ZERO(&fds); + FD_SET(pVNC->rdpListenSock, &fds); + tv.tv_sec = 0; + tv.tv_usec = 0; + nfds = select(pVNC->rdpListenSock + 1, &fds, NULL, NULL, &tv); + if (nfds == 0) { + return; + } + if (nfds < 0) { + if (errno != EINTR) + rfbLogPerror("httpCheckFds: select"); + return; + } + + if (pVNC->rdpListenSock != -1 && FD_ISSET(pVNC->rdpListenSock, &fds)) { + + if ((sock = accept(pVNC->rdpListenSock, + (struct sockaddr *)&addr, &addrlen)) < 0) { + rfbLogPerror("rdpCheckFds: accept"); + return; + } + + if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) { + rfbLogPerror("rdpCheckFds: fcntl"); + close(sock); + return; + } + + if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + (char *)&one, sizeof(one)) < 0) { + rfbLogPerror("rdpCheckFds: setsockopt"); + close(sock); + return; + } + + rfbLog("\n"); + + rfbLog("Got RDP connection from client %s\n", inet_ntoa(addr.sin_addr)); + + AddEnabledDevice(sock); + + rdpNewClient(pScreen, sock); + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/README xorg-server-1.4/hw/vnc/README --- xorg-server-1.4.orig/hw/vnc/README 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/README 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,14 @@ + +This is the directory containing the code specific to the TightVNC X server (Xvnc). +Note that within this directory the name RFB is still used instead of VNC. + +NOTE: + +The is the new XFree86 v4 architecture VNC server code. + +Modified entirely by Alan Hourihane <alanh@fairlite.demon.co.uk> + +For information please visit http://xf4vnc.sourceforge.net + +Moved to X.org modular tree by Brian Paul. + diff -pNur xorg-server-1.4.orig/hw/vnc/rfb.h xorg-server-1.4/hw/vnc/rfb.h --- xorg-server-1.4.orig/hw/vnc/rfb.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rfb.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,749 @@ +/* + * rfb.h - header file for RFB DDX implementation. + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2000-2004 Const Kaplinsky. All Rights Reserved. + * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef RFB_H_INCLUDED +#define RFB_H_INCLUDED + +#ifdef HAVE_DMX_CONFIG_H +#include "dmx-config.h" +#endif + +#ifdef DMXVNC +#include <dmx.h> +#else +#include <dix-config.h> +#endif + +#include <zlib.h> +#ifdef XFREE86VNC +#include "xf86.h" +#endif +#include "scrnintstr.h" +#include "colormapst.h" +#include "dixstruct.h" +#include "gcstruct.h" +#include "regionstr.h" +#include "windowstr.h" +#include "dixfontstr.h" +#include "mipointer.h" +#include <rfbproto.h> +#include <vncauth.h> +#define _VNC_SERVER +#include <X11/extensions/vnc.h> +#include "picturestr.h" + +#if defined(sun) || defined(hpux) +#define SOCKLEN_T int +#else +#define SOCKLEN_T socklen_t +#endif + +/* It's a good idea to keep these values a bit greater than required. */ +#define MAX_ENCODINGS 10 +#define MAX_SECURITY_TYPES 4 +#define MAX_TUNNELING_CAPS 16 +#define MAX_AUTH_CAPS 16 + +/* + * HTTP_BUF_SIZE for http transfers + */ +#define HTTP_BUF_SIZE 32768 + +/* + * UPDATE_BUF_SIZE must be big enough to send at least one whole line of the + * framebuffer. So for a max screen width of say 2K with 32-bit pixels this + * means 8K minimum. + */ +#define UPDATE_BUF_SIZE 30000 + +#if XFREE86VNC || defined(DMXVNC) +#include "vncint.h" +#define VNCSCREENPTR(ptr) \ + vncScreenPtr pVNC = VNCPTR(ptr) +#else +#define VNCSCREENPTR(ptr) \ +/* Soon \ + rfbScreenInfoPtr pVNC = rfbScreen[ptr->myNum] \ +*/ \ + rfbScreenInfoPtr pVNC = &rfbScreen +#endif + +/* + * Per-screen (framebuffer) structure. There is only one of these, since we + * don't allow the X server to have multiple screens. + */ + +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; + Bool noCursor; + Bool rfbAlwaysShared; + Bool rfbNeverShared; + Bool rfbDontDisconnect; + Bool rfbUserAccept; + Bool rfbViewOnly; + ColormapPtr savedColormap; + ColormapPtr rfbInstalledColormap; + 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 paddedWidthInBytes; + int height; + int depth; + int bitsPerPixel; + int sizeInBytes; + unsigned char *pfbMemory; + Pixel blackPixel; + Pixel whitePixel; + + /* 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; +#ifdef CHROMIUM + RealizeWindowProcPtr RealizeWindow; + UnrealizeWindowProcPtr UnrealizeWindow; + DestroyWindowProcPtr DestroyWindow; + ResizeWindowProcPtr ResizeWindow; + PositionWindowProcPtr PositionWindow; + ClipNotifyProcPtr ClipNotify; +#endif +#ifdef RENDER + CompositeProcPtr Composite; +#endif + +} rfbScreenInfo, *rfbScreenInfoPtr; + + +/* + * rfbTranslateFnType is the type of translation functions. + */ + +struct rfbClientRec; +typedef void (*rfbTranslateFnType)(ScreenPtr pScreen, + char *table, rfbPixelFormat *in, + rfbPixelFormat *out, + unsigned char *optr, + int bytesBetweenInputLines, + int width, int height, + int x, int y); + + +/* + * Per-client structure. + */ + +typedef struct rfbClientRec { + int sock; + char *host; + char *login; + + int protocol_minor_ver; /* RFB protocol minor version in use. */ + Bool protocol_tightvnc; /* TightVNC protocol extensions enabled */ + + /* Possible client states: */ + + enum { + RFB_PROTOCOL_VERSION, /* establishing protocol version */ + RFB_SECURITY_TYPE, /* negotiating security (RFB v.3.7) */ + RFB_TUNNELING_TYPE, /* establishing tunneling (RFB v.3.7t) */ + RFB_AUTH_TYPE, /* negotiating authentication (RFB v.3.7t) */ + RFB_AUTHENTICATION, /* authenticating (VNC authentication) */ + RFB_INITIALISATION, /* sending initialisation messages */ + RFB_NORMAL /* normal protocol messages */ + } state; + + Bool viewOnly; /* Do not accept input from this client. */ + + Bool reverseConnection; + + Bool readyForSetColourMapEntries; + + Bool useCopyRect; + int preferredEncoding; + int correMaxWidth, correMaxHeight; + + /* The list of security types sent to this client (protocol 3.7). + Note that the first entry is the number of list items following. */ + + CARD8 securityTypes[MAX_SECURITY_TYPES + 1]; + + /* Lists of capability codes sent to clients. We remember these + lists to restrict clients from choosing those tunneling and + authentication types that were not advertised. */ + + int nAuthCaps; + CARD32 authCaps[MAX_AUTH_CAPS]; + + /* This is not useful while we don't support tunneling: + int nTunnelingCaps; + CARD32 tunnelingCaps[MAX_TUNNELING_CAPS]; */ + + /* The following member is only used during VNC authentication */ + + CARD8 authChallenge[CHALLENGESIZE]; + + /* The following members represent the update needed to get the client's + framebuffer from its present state to the current state of our + framebuffer. + + If the client does not accept CopyRect encoding then the update is + simply represented as the region of the screen which has been modified + (modifiedRegion). + + If the client does accept CopyRect encoding, then the update consists of + two parts. First we have a single copy from one region of the screen to + another (the destination of the copy is copyRegion), and second we have + the region of the screen which has been modified in some other way + (modifiedRegion). + + Although the copy is of a single region, this region may have many + rectangles. When sending an update, the copyRegion is always sent + before the modifiedRegion. This is because the modifiedRegion may + overlap parts of the screen which are in the source of the copy. + + In fact during normal processing, the modifiedRegion may even overlap + the destination copyRegion. Just before an update is sent we remove + from the copyRegion anything in the modifiedRegion. */ + + RegionRec copyRegion; /* the destination region of the copy */ + int copyDX, copyDY; /* the translation by which the copy happens */ + + RegionRec modifiedRegion; /* the region of the screen modified in any + other way */ + + /* As part of the FramebufferUpdateRequest, a client can express interest + in a subrectangle of the whole framebuffer. This is stored in the + requestedRegion member. In the normal case this is the whole + framebuffer if the client is ready, empty if it's not. */ + + RegionRec requestedRegion; + + /* The following members represent the state of the "deferred update" timer + - when the framebuffer is modified and the client is ready, in most + cases it is more efficient to defer sending the update by a few + milliseconds so that several changes to the framebuffer can be combined + into a single update. */ + + Bool deferredUpdateScheduled; + OsTimerPtr deferredUpdateTimer; + + /* translateFn points to the translation function which is used to copy + and translate a rectangle from the framebuffer to an output buffer. */ + + rfbTranslateFnType translateFn; + + char *translateLookupTable; + + rfbPixelFormat format; + + /* statistics */ + + int rfbBytesSent[MAX_ENCODINGS]; + int rfbRectanglesSent[MAX_ENCODINGS]; + int rfbLastRectMarkersSent; + int rfbLastRectBytesSent; + int rfbCursorShapeBytesSent; + int rfbCursorShapeUpdatesSent; + int rfbCursorPosBytesSent; + int rfbCursorPosUpdatesSent; + int rfbFramebufferUpdateMessagesSent; + int rfbRawBytesEquivalent; + int rfbKeyEventsRcvd; + int rfbPointerEventsRcvd; + + /* zlib encoding -- necessary compression state info per client */ + + struct z_stream_s compStream; + Bool compStreamInited; + + CARD32 zlibCompressLevel; + + /* tight encoding -- preserve zlib streams' state for each client */ + + z_stream zsStruct[4]; + Bool zsActive[4]; + int zsLevel[4]; + int tightCompressLevel; + int tightQualityLevel; + + Bool enableLastRectEncoding; /* client supports LastRect encoding */ + Bool enableCursorShapeUpdates; /* client supports cursor shape updates */ + Bool enableCursorPosUpdates; /* client supports PointerPos updates */ +#ifdef CHROMIUM + Bool enableChromiumEncoding; /* client supports Chromium encoding */ +#endif + Bool useRichCursorEncoding; /* rfbEncodingRichCursor is preferred */ + Bool cursorWasChanged; /* cursor shape update should be sent */ + Bool cursorWasMoved; /* cursor position update should be sent */ + + int cursorX, cursorY; /* client's cursor position */ + + struct rfbClientRec *next; + + ScreenPtr pScreen; + int userAccepted; + +#ifdef CHROMIUM + unsigned int chromium_port; + unsigned int chromium_msport; +#endif +} rfbClientRec, *rfbClientPtr; + +#ifdef CHROMIUM +typedef struct CRWindowTable { + unsigned long CRwinId; + unsigned long XwinId; + BoxPtr clipRects; + int numRects; + struct CRWindowTable *next; +} CRWindowTable, *CRWindowTablePtr; + +extern struct CRWindowTable *windowTable; +#endif + +/* + * This macro is used to test whether there is a framebuffer update needing to + * be sent to the client. + */ + +#define FB_UPDATE_PENDING(cl) \ + ((!(cl)->enableCursorShapeUpdates && !pVNC->cursorIsDrawn) || \ + ((cl)->enableCursorShapeUpdates && (cl)->cursorWasChanged) || \ + ((cl)->enableCursorPosUpdates && (cl)->cursorWasMoved) || \ + REGION_NOTEMPTY(((cl)->pScreen),&(cl)->copyRegion) || \ + REGION_NOTEMPTY(((cl)->pScreen),&(cl)->modifiedRegion)) + +/* + * This macro creates an empty region (ie. a region with no areas) if it is + * given a rectangle with a width or height of zero. It appears that + * REGION_INTERSECT does not quite do the right thing with zero-width + * rectangles, but it should with completely empty regions. + */ + +#define SAFE_REGION_INIT(pscreen, preg, rect, size) \ +{ \ + if ( ( (rect) ) && \ + ( ( (rect)->x2 == (rect)->x1 ) || \ + ( (rect)->y2 == (rect)->y1 ) ) ) { \ + REGION_NULL( (pscreen), (preg) ); \ + } else { \ + REGION_INIT( (pscreen), (preg), (rect), (size) ); \ + } \ +} + +/* + * An rfbGCRec is where we store the pointers to the original GC funcs and ops + * which we wrap (NULL means not wrapped). + */ + +typedef struct { + GCFuncs *wrapFuncs; + GCOps *wrapOps; +} rfbGCRec, *rfbGCPtr; + + + +/* + * Macros for endian swapping. + */ + +#define Swap16(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) + +#define Swap32(l) (((l) >> 24) | \ + (((l) & 0x00ff0000) >> 8) | \ + (((l) & 0x0000ff00) << 8) | \ + ((l) << 24)) + +static const int rfbEndianTest = 1; + +#define Swap16IfLE(s) (*(const char *)&rfbEndianTest ? Swap16(s) : (s)) + +#define Swap32IfLE(l) (*(const char *)&rfbEndianTest ? Swap32(l) : (l)) + + +/* + * Macro to fill in an rfbCapabilityInfo structure (protocol 3.130). + * Normally, using macros is no good, but this macro saves us from + * writing constants twice -- it constructs signature names from codes. + * Note that "code_sym" argument should be a single symbol, not an expression. + */ + +#define SetCapInfo(cap_ptr, code_sym, vendor) \ +{ \ + rfbCapabilityInfo *pcap; \ + pcap = (cap_ptr); \ + pcap->code = Swap32IfLE(code_sym); \ + memcpy(pcap->vendorSignature, (vendor), \ + sz_rfbCapabilityInfoVendor); \ + memcpy(pcap->nameSignature, sig_##code_sym, \ + sz_rfbCapabilityInfoName); \ +} + + +/* init.c */ + +extern char *desktopName; +extern char rfbThisHost[]; +extern Atom VNC_LAST_CLIENT_ID; + +extern rfbScreenInfo rfbScreen; +extern int rfbGCIndex; + +extern int inetdSock; + +extern int rfbBitsPerPixel(int depth); +extern void rfbLog(char *format, ...); +extern void rfbLogPerror(char *str); + + +/* sockets.c */ + +extern int rfbMaxClientWait; + +extern Bool rfbInitSockets(ScreenPtr pScreen); +extern void rfbDisconnectUDPSock(ScreenPtr pScreen); +extern void rfbCloseSock(ScreenPtr pScreen, int sock); +extern void rfbCheckFds(ScreenPtr pScreen); +extern void rfbWaitForClient(int sock); +extern int rfbConnect(ScreenPtr pScreen, char *host, int port); + +extern int ReadExact(int sock, char *buf, int len); +extern int WriteExact(int sock, char *buf, int len); +extern int ListenOnTCPPort(ScreenPtr pScreen, int port); +extern int ListenOnUDPPort(ScreenPtr pScreen, int port); +extern int ConnectToTcpAddr(char *host, int port); + + +/* cmap.c */ + + +extern int rfbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps); +extern void rfbInstallColormap(ColormapPtr pmap); +extern void rfbUninstallColormap(ColormapPtr pmap); +extern void rfbStoreColors(ColormapPtr pmap, int ndef, xColorItem *pdefs); + + +/* draw.c */ + +extern int rfbDeferUpdateTime; + +extern void +rfbComposite( + CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height +); + +extern void rfbGlyphs( + CARD8 op, + PicturePtr pSrc, + PicturePtr pDst, + PictFormatPtr maskFormat, + INT16 xSrc, + INT16 ySrc, + int nlistInit, + GlyphListPtr listInit, + GlyphPtr *glyphsInit +); +extern Bool rfbCloseScreen(int,ScreenPtr); +extern Bool rfbCreateGC(GCPtr); +extern void rfbPaintWindowBackground(WindowPtr, RegionPtr, int what); +extern void rfbPaintWindowBorder(WindowPtr, RegionPtr, int what); +extern void rfbCopyWindow(WindowPtr, DDXPointRec, RegionPtr); +#ifdef CHROMIUM +extern Bool rfbRealizeWindow(WindowPtr); +extern Bool rfbUnrealizeWindow(WindowPtr); +extern Bool rfbDestroyWindow(WindowPtr); +extern void rfbResizeWindow(WindowPtr, int x, int y, unsigned int w, unsigned int h, WindowPtr pSib); +extern Bool rfbPositionWindow(WindowPtr, int x, int y); +extern void rfbClipNotify(WindowPtr, int x, int y); +#endif +extern void rfbClearToBackground(WindowPtr, int x, int y, int w, + int h, Bool generateExposures); +extern RegionPtr rfbRestoreAreas(WindowPtr, RegionPtr); +extern void rfbScheduleUpdate(ScreenPtr pScreen); + +/* dispcur.c */ +extern Bool rfbDCInitialize(ScreenPtr pScreen, miPointerScreenFuncPtr screenFuncs); + + +/* cutpaste.c */ + +extern void rfbSetXCutText(char *str, int len); +extern void rfbGotXCutText(char *str, int len); + + +/* kbdptr.c */ + +extern Bool compatibleKbd; +extern unsigned char ptrAcceleration; + +extern void PtrDeviceInit(void); +extern void PtrDeviceOn(DeviceIntPtr pDev); +extern void PtrDeviceOff(void); +extern void PtrDeviceControl(DeviceIntPtr dev, PtrCtrl *ctrl); +extern void PtrAddEvent(int buttonMask, int x, int y, rfbClientPtr cl); + +extern void KbdDeviceInit(DeviceIntPtr pDevice, KeySymsPtr pKeySyms, CARD8 *pModMap); +extern void KbdDeviceOn(void); +extern void KbdDeviceOff(void); +extern void KbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl); +extern void KbdReleaseAllKeys(void); + +extern void vncSetKeyboardDevice(DeviceIntPtr kbd); +extern void vncSetPointerDevice(DeviceIntPtr ptr); + + +/* rfbserver.c */ + + +extern rfbClientPtr rfbClientHead; +extern rfbClientPtr pointerClient; + +extern void rfbNewClientConnection(ScreenPtr pScreen, int sock); +extern rfbClientPtr rfbReverseConnection(ScreenPtr pScreen, char *host, int port); +extern void rfbRootPropertyChange(ScreenPtr pScreen); +extern void rfbClientConnectionGone(int sock); +extern void rfbProcessClientMessage(ScreenPtr pScreen, int sock); +extern void rfbClientConnFailed(rfbClientPtr cl, char *reason); +extern void rfbNewUDPConnection(int sock); +extern void rfbProcessUDPInput(ScreenPtr pScreen, int sock); +extern Bool rfbSendFramebufferUpdate(ScreenPtr pScreen, rfbClientPtr cl); +extern Bool rfbSendRectEncodingRaw(rfbClientPtr cl, int x,int y,int w,int h); +extern Bool rfbSendUpdateBuf(rfbClientPtr cl); +extern Bool rfbSendSetColourMapEntries(rfbClientPtr cl, int firstColour, + int nColours); +extern void rfbSendBell(void); +extern void rfbSendServerCutText(char *str, int len); +extern void rfbUserAllow(int sock, int accept); +extern void rfbSetClip (WindowPtr pWin, BOOL enable); + +extern int GenerateVncConnectedEvent(int sock); +extern int GenerateVncDisconnectedEvent(int sock); + +#ifdef CHROMIUM +extern void rfbSendChromiumWindowShow(unsigned int winid, unsigned int show); +extern void rfbSendChromiumWindowDestroy(unsigned int winid); +extern void rfbSendChromiumMoveResizeWindow(unsigned int winid, int x, int y, unsigned int w, unsigned int h); +extern void rfbSendChromiumClipList(unsigned int winid, BoxPtr pClipRects, int numClipRects); +#endif + +/* translate.c */ + +extern Bool rfbEconomicTranslate; + +extern void rfbTranslateNone(ScreenPtr pScreen, char *table, rfbPixelFormat *in, + rfbPixelFormat *out, + unsigned char *optr, + int bytesBetweenInputLines, + int width, int height, + int x, int y); +extern Bool rfbSetTranslateFunction(rfbClientPtr cl); +extern void rfbSetClientColourMaps(int firstColour, int nColours); +extern Bool rfbSetClientColourMap(rfbClientPtr cl, int firstColour, + int nColours); + + +/* httpd.c */ + +extern Bool httpInitSockets(ScreenPtr pScreen); +extern void httpCheckFds(ScreenPtr pScreen); + + +/* vncInit.c */ +extern void VNCInitForDMX(void); +extern void rfbWakeupHandlerDMX(void); + + +/* vncext.c */ + +#ifdef CHROMIUM +extern void rfbSendChromiumStart(unsigned int ipaddress, unsigned int crServerPort, unsigned int mothershipPort); +extern void rfbChromiumMonitorWindowID(unsigned int cr_windowid, unsigned long windowid); +int GenerateVncChromiumConnectedEvent(int sock); +#endif + + +/* auth.c */ + +extern void rfbAuthNewClient(rfbClientPtr cl); +extern void rfbProcessClientSecurityType(rfbClientPtr cl); +extern void rfbProcessClientTunnelingType(rfbClientPtr cl); +extern void rfbProcessClientAuthType(rfbClientPtr cl); +extern void rfbVncAuthProcessResponse(rfbClientPtr cl); + +/* Functions to prevent too many successive authentication failures */ +extern Bool rfbAuthConsiderBlocking(rfbClientPtr cl); +extern void rfbAuthUnblock(rfbClientPtr cl); +extern Bool rfbAuthIsBlocked(rfbClientPtr cl); + +/* loginauth.c */ + +extern void rfbLoginAuthProcessClientMessage(rfbClientPtr cl); + +/* rre.c */ + +extern Bool rfbSendRectEncodingRRE(rfbClientPtr cl, int x,int y,int w,int h); + + +/* corre.c */ + +extern Bool rfbSendRectEncodingCoRRE(rfbClientPtr cl, int x,int y,int w,int h); + + +/* hextile.c */ + +extern Bool rfbSendRectEncodingHextile(rfbClientPtr cl, int x, int y, int w, + int h); + + +/* zlib.c */ + +/* Minimum zlib rectangle size in bytes. Anything smaller will + * not compress well due to overhead. + */ +#define VNC_ENCODE_ZLIB_MIN_COMP_SIZE (17) + +/* Set maximum zlib rectangle size in pixels. Always allow at least + * two scan lines. + */ +#define ZLIB_MAX_RECT_SIZE (128*256) +#define ZLIB_MAX_SIZE(min) ((( min * 2 ) > ZLIB_MAX_RECT_SIZE ) ? \ + ( min * 2 ) : ZLIB_MAX_RECT_SIZE ) + +extern Bool rfbSendRectEncodingZlib(rfbClientPtr cl, int x, int y, int w, + int h); + + +/* tight.c */ + +#define TIGHT_DEFAULT_COMPRESSION 6 + +extern Bool rfbTightDisableGradient; + +extern int rfbNumCodedRectsTight(rfbClientPtr cl, int x,int y,int w,int h); +extern Bool rfbSendRectEncodingTight(rfbClientPtr cl, int x,int y,int w,int h); + + +/* cursor.c */ + +extern Bool rfbSendCursorShape(rfbClientPtr cl, ScreenPtr pScreen); +extern Bool rfbSendCursorPos(rfbClientPtr cl, ScreenPtr pScreen); + + +/* stats.c */ + +extern void rfbResetStats(rfbClientPtr cl); +extern void rfbPrintStats(rfbClientPtr cl); + + +/* dpms.c */ + +extern Bool DPMSSupported(void); +extern int DPSMGet(int *level); +extern void DPMSSet(int level); + + +#endif /* RFB_H_INCLUDED */ diff -pNur xorg-server-1.4.orig/hw/vnc/rfbkeyb.c xorg-server-1.4/hw/vnc/rfbkeyb.c --- xorg-server-1.4.orig/hw/vnc/rfbkeyb.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rfbkeyb.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,405 @@ +/* + * 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> + */ + +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#if XFREE86VNC +#ifndef XFree86LOADER +#include <unistd.h> +#include <errno.h> +#endif + +#include <misc.h> +#include <xf86.h> +#if !defined(DGUX) +#include <xisb.h> +#endif +#include <xf86Xinput.h> +#include <exevents.h> /* Needed for InitValuator/Proximity stuff */ +#include <mipointer.h> + +#ifdef XFree86LOADER +#include <xf86Module.h> +#endif +#else +#include <dix.h> +#include <mipointer.h> +#endif +#include "rfb.h" + + +extern void rfbSendBell(void); +extern DeviceIntPtr kbdDevice; + +static const char *DEFAULTS[] = { + NULL +}; + +#include <X11/keysym.h> +#include "keyboard.h" + +#ifdef XKB +#include <X11/extensions/XKB.h> +#include <X11/extensions/XKBstr.h> +#include <X11/extensions/XKBsrv.h> + +#if XFREE86VNC + /* + * would like to use an XkbComponentNamesRec here but can't without + * pulling in a bunch of header files. :-( + */ +static char * xkbkeymap; +static char * xkbkeycodes; +static char * xkbtypes; +static char * xkbcompat; +static char * xkbsymbols; +static char * xkbgeometry; +static Bool xkbcomponents_specified; +static char * xkbrules; +static char * xkbmodel; +static char * xkblayout; +static char * xkbvariant; +static char * xkboptions; +#endif +#endif + +void +KbdDeviceInit(DeviceIntPtr pDevice, KeySymsPtr pKeySyms, CARD8 *pModMap) +{ + int i; + + for (i = 0; i < MAP_LENGTH; i++) + pModMap[i] = NoSymbol; + + pModMap[CONTROL_L_KEY_CODE] = ControlMask; + pModMap[CONTROL_R_KEY_CODE] = ControlMask; + pModMap[SHIFT_L_KEY_CODE] = ShiftMask; + pModMap[SHIFT_R_KEY_CODE] = ShiftMask; + pModMap[META_L_KEY_CODE] = Mod1Mask; + pModMap[META_R_KEY_CODE] = Mod1Mask; + pModMap[ALT_L_KEY_CODE] = Mod1Mask; + pModMap[ALT_R_KEY_CODE] = Mod1Mask; + + pKeySyms->minKeyCode = MIN_KEY_CODE; + pKeySyms->maxKeyCode = MAX_KEY_CODE; + pKeySyms->mapWidth = GLYPHS_PER_KEY; + + pKeySyms->map = (KeySym *)xalloc(sizeof(KeySym) + * MAP_LENGTH * GLYPHS_PER_KEY); + + if (!pKeySyms->map) { + ErrorF("xalloc failed\n"); + exit(1); + } + + for (i = 0; i < MAP_LENGTH * GLYPHS_PER_KEY; i++) + pKeySyms->map[i] = NoSymbol; + + for (i = 0; i < N_PREDEFINED_KEYS * GLYPHS_PER_KEY; i++) { + pKeySyms->map[i] = map[i]; + } +} + +void +KbdDeviceOn(void) +{ +} + + +void +KbdDeviceOff(void) +{ +} + +#if XFREE86VNC +static int +xf86rfbKeybControlProc(DeviceIntPtr device, int onoff) +{ + KeySymsRec keySyms; + CARD8 modMap[MAP_LENGTH]; + DevicePtr pDev = (DevicePtr)device; + + switch (onoff) + { + case DEVICE_INIT: + vncSetKeyboardDevice(device); + KbdDeviceInit(device, &keySyms, modMap); +#ifdef XKB + if (noXkbExtension) { +#endif + InitKeyboardDeviceStruct(pDev, &keySyms, modMap, + (BellProcPtr)rfbSendBell, + (KbdCtrlProcPtr)NoopDDA); +#ifdef XKB + } else { + XkbComponentNamesRec names; + if (xkbkeymap) { + names.keymap = xkbkeymap; + names.keycodes = NULL; + names.types = NULL; + names.compat = NULL; + names.symbols = NULL; + names.geometry = NULL; + } else { + names.keymap = NULL; + names.keycodes = xkbkeycodes; + names.types = xkbtypes; + names.compat = xkbcompat; + names.symbols = xkbsymbols; + names.geometry = xkbgeometry; + } + if ((xkbkeymap || xkbcomponents_specified) + && (xkbmodel == NULL || xkblayout == NULL)) { + xkbrules = NULL; + } +#if 0 + XkbSetRulesDflts(xkbrules, xkbmodel, + xkblayout, xkbvariant, + xkboptions); +#endif + XkbInitKeyboardDeviceStruct(device, + &names, + &keySyms, + modMap, + (BellProcPtr)rfbSendBell, + (KbdCtrlProcPtr)NoopDDA); + } +#endif + break; + case DEVICE_ON: + pDev->on = TRUE; + KbdDeviceOn(); + break; + case DEVICE_OFF: + pDev->on = FALSE; + KbdDeviceOff(); + break; + case DEVICE_CLOSE: + vncSetKeyboardDevice(NULL); + if (pDev->on) + KbdDeviceOff(); + break; + } + return Success; +} + +static void +xf86rfbKeybUninit(InputDriverPtr drv, + InputInfoPtr pInfo, + int flags) +{ + xf86rfbKeybControlProc(pInfo->dev, DEVICE_OFF); +} + +static InputInfoPtr +xf86rfbKeybInit(InputDriverPtr drv, + IDevPtr dev, + int flags) +{ + InputInfoPtr pInfo; + char *s; + Bool from; + + if (!(pInfo = xf86AllocateInput(drv, 0))) + return NULL; + + /* Initialise the InputInfoRec. */ + pInfo->name = dev->identifier; + pInfo->type_name = "rfbKeyb"; + pInfo->flags = XI86_KEYBOARD_CAPABLE; + pInfo->device_control = xf86rfbKeybControlProc; + pInfo->read_input = NULL; +#if 0 + pInfo->motion_history_proc = NULL; +#endif + pInfo->history_size = 0; + pInfo->control_proc = NULL; + pInfo->close_proc = NULL; + pInfo->switch_mode = NULL; + pInfo->conversion_proc = NULL; + pInfo->reverse_conversion_proc = NULL; + pInfo->fd = -1; + pInfo->dev = NULL; + pInfo->private_flags = 0; + pInfo->always_core_feedback = 0; + pInfo->conf_idev = dev; + + /* Collect the options, and process the common options. */ + xf86CollectInputOptions(pInfo, DEFAULTS, NULL); + xf86ProcessCommonOptions(pInfo, pInfo->options); + + /* Mark the device configured */ + pInfo->flags |= XI86_CONFIGURED; + +#ifdef XKB + from = X_DEFAULT; + if (noXkbExtension) + from = X_CMDLINE; + else if (xf86FindOption(dev->commonOptions, "XkbDisable")) { + noXkbExtension = + xf86SetBoolOption(dev->commonOptions, "XkbDisable", FALSE); + from = X_CONFIG; + } + if (noXkbExtension) + xf86Msg(from, "XKB: disabled\n"); + +#define NULL_IF_EMPTY(s) (s[0] ? s : (xfree(s), (char *)NULL)) + + if (!noXkbExtension) { + if ((s = xf86SetStrOption(dev->commonOptions, "XkbKeymap", NULL))) { + xkbkeymap = NULL_IF_EMPTY(s); + xf86Msg(X_CONFIG, "XKB: keymap: \"%s\" " + "(overrides other XKB settings)\n", xkbkeymap); + } else { + if ((s = xf86SetStrOption(dev->commonOptions, "XkbCompat", NULL))) { + xkbcompat = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: compat: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbTypes", NULL))) { + xkbtypes = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: types: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbKeycodes", NULL))) { + xkbkeycodes = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: keycodes: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbGeometry", NULL))) { + xkbgeometry = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: geometry: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbSymbols", NULL))) { + xkbsymbols = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: symbols: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbRules", NULL))) { + xkbrules = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: rules: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbModel", NULL))) { + xkbmodel = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: model: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbLayout", NULL))) { + xkblayout = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: layout: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbVariant", NULL))) { + xkbvariant = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: variant: \"%s\"\n", s); + } + + if ((s = xf86SetStrOption(dev->commonOptions, "XkbOptions", NULL))) { + xkboptions = NULL_IF_EMPTY(s); + xkbcomponents_specified = TRUE; + xf86Msg(X_CONFIG, "XKB: options: \"%s\"\n", s); + } + } + } +#undef NULL_IF_EMPTY +#endif + + /* Return the configured device */ + return (pInfo); +} + +#ifdef XFree86LOADER +static +#endif +InputDriverRec RFBKEYB = { + 1, /* driver version */ + "rfbkeyb", /* driver name */ + NULL, /* identify */ + xf86rfbKeybInit, /* pre-init */ + xf86rfbKeybUninit, /* un-init */ + NULL, /* module */ + 0 /* ref count */ +}; + +/* + *************************************************************************** + * + * Dynamic loading functions + * + *************************************************************************** + */ +#ifdef XFree86LOADER +static void +xf86rfbKeybUnplug(pointer p) +{ +} + +static pointer +xf86rfbKeybPlug(pointer module, + pointer options, + int *errmaj, + int *errmin) +{ + xf86AddInputDriver(&RFBKEYB, module, 0); + + return module; +} + +void +vncInitKeyb(void) +{ + xf86AddInputDriver(&RFBKEYB, NULL, 0); +} + +static XF86ModuleVersionInfo xf86rfbKeybVersionRec = +{ + "rfbkeyb", + "xf4vnc Project, see http://xf4vnc.sf.net", + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, + 1, 0, 0, + ABI_CLASS_XINPUT, + ABI_XINPUT_VERSION, + MOD_CLASS_XINPUT, + {0, 0, 0, 0} /* signature, to be patched into the file by */ + /* a tool */ +}; + +XF86ModuleData rfbkeybModuleData = {&xf86rfbKeybVersionRec, + xf86rfbKeybPlug, + xf86rfbKeybUnplug}; + +#endif /* XFree86LOADER */ +#endif diff -pNur xorg-server-1.4.orig/hw/vnc/rfbmouse.c xorg-server-1.4/hw/vnc/rfbmouse.c --- xorg-server-1.4.orig/hw/vnc/rfbmouse.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rfbmouse.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,260 @@ +/* + * 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> + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include <X11/keysym.h> +#if XFREE86VNC +#ifndef XFree86LOADER +#include <unistd.h> +#include <errno.h> +#endif + +#include <misc.h> +#include <xf86.h> +#if !defined(DGUX) +#include <xisb.h> +#endif +#include <xf86Xinput.h> +#include <exevents.h> /* Needed for InitValuator/Proximity stuff */ +#include <mipointer.h> + +#ifdef XFree86LOADER +#include <xf86Module.h> +#endif + +static const char *DEFAULTS[] = { + NULL +}; +#else +#include <dix.h> +#include <mipointer.h> +#endif +#include "rfb.h" + + +unsigned char ptrAcceleration = 50; + +void +PtrDeviceOn(DeviceIntPtr pDev) +{ +#if 0 + ptrAcceleration = (unsigned char)pDev->ptrfeed->ctrl.num; +#endif +} + +void +PtrDeviceInit(void) +{ +} + +void +PtrDeviceOff(void) +{ +} + + +void +PtrDeviceControl(DeviceIntPtr dev, PtrCtrl *ctrl) +{ +#if 0 + ptrAcceleration = (char)ctrl->num; + + if (udpSockConnected) { + if (write(udpSock, &ptrAcceleration, 1) <= 0) { + ErrorF("PtrDeviceControl: UDP input: write"); + rfbDisconnectUDPSock(); + } + } +#endif +} + +#if XFREE86VNC +static int +xf86rfbMouseControlProc(DeviceIntPtr device, int onoff) +{ + BYTE map[6]; + DevicePtr pDev = (DevicePtr)device; + void *func1; + int (*func2)(void); + + if (LoaderSymbol("GetMotionHistory")) + func1 = LoaderSymbol("GetMotionHistory"); + else + func1 = LoaderSymbol("miPointerGetMotionEvents"); + + if (LoaderSymbol("GetMotionHistorySize")) + func2 = LoaderSymbol("GetMotionHistorySize"); + else + func2 = LoaderSymbol("miPointerGetMotionBufferSize"); + + + switch (onoff) + { + case DEVICE_INIT: + vncSetPointerDevice(device); + PtrDeviceInit(); + map[1] = 1; + map[2] = 2; + map[3] = 3; + map[4] = 4; + map[5] = 5; + InitPointerDeviceStruct(pDev, map, 5, + func1, + PtrDeviceControl, + (*func2)(), 2); + break; + + case DEVICE_ON: + pDev->on = TRUE; + PtrDeviceOn(device); + break; + + case DEVICE_OFF: + pDev->on = FALSE; + PtrDeviceOff(); + break; + + case DEVICE_CLOSE: + vncSetPointerDevice(NULL); + if (pDev->on) + PtrDeviceOff(); + break; + } + return Success; +} + +static void +xf86rfbMouseUninit(InputDriverPtr drv, + InputInfoPtr pInfo, + int flags) +{ + xf86rfbMouseControlProc(pInfo->dev, DEVICE_OFF); +} + +static InputInfoPtr +xf86rfbMouseInit(InputDriverPtr drv, + IDevPtr dev, + int flags) +{ + InputInfoPtr pInfo; + + if (!(pInfo = xf86AllocateInput(drv, 0))) + return NULL; + + /* Initialise the InputInfoRec. */ + pInfo->name = dev->identifier; + pInfo->type_name = "rfbMouse"; + pInfo->flags = XI86_POINTER_CAPABLE | XI86_SEND_DRAG_EVENTS; + pInfo->device_control = xf86rfbMouseControlProc; + pInfo->read_input = NULL; +#if 0 + pInfo->motion_history_proc = xf86GetMotionEvents; +#endif + pInfo->history_size = 0; + pInfo->control_proc = NULL; + pInfo->close_proc = NULL; + pInfo->switch_mode = NULL; + pInfo->conversion_proc = NULL; + pInfo->reverse_conversion_proc = NULL; + pInfo->fd = -1; + pInfo->dev = NULL; + pInfo->private_flags = 0; + pInfo->always_core_feedback = 0; + pInfo->conf_idev = dev; + + /* Collect the options, and process the common options. */ + xf86CollectInputOptions(pInfo, DEFAULTS, NULL); + xf86ProcessCommonOptions(pInfo, pInfo->options); + + /* Mark the device configured */ + pInfo->flags |= XI86_CONFIGURED; + + /* Return the configured device */ + return (pInfo); +} + +#ifdef XFree86LOADER +static +#endif +InputDriverRec RFBMOUSE = { + 1, /* driver version */ + "rfbmouse", /* driver name */ + NULL, /* identify */ + xf86rfbMouseInit, /* pre-init */ + xf86rfbMouseUninit, /* un-init */ + NULL, /* module */ + 0 /* ref count */ +}; + +/* + *************************************************************************** + * + * Dynamic loading functions + * + *************************************************************************** + */ +#ifdef XFree86LOADER +static void +xf86rfbMouseUnplug(pointer p) +{ +} + +static pointer +xf86rfbMousePlug(pointer module, + pointer options, + int *errmaj, + int *errmin) +{ + xf86AddInputDriver(&RFBMOUSE, module, 0); + + return module; +} + +void +vncInitMouse(void) +{ + xf86AddInputDriver(&RFBMOUSE, NULL, 0); +} + +static XF86ModuleVersionInfo xf86rfbMouseVersionRec = +{ + "rfbmouse", + "xf4vnc Project, see http://xf4vnc.sf.net", + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, + 1, 0, 0, + ABI_CLASS_XINPUT, + ABI_XINPUT_VERSION, + MOD_CLASS_XINPUT, + {0, 0, 0, 0} /* signature, to be patched into the file by */ + /* a tool */ +}; + +XF86ModuleData rfbmouseModuleData = {&xf86rfbMouseVersionRec, + xf86rfbMousePlug, + xf86rfbMouseUnplug}; + +#endif /* XFree86LOADER */ +#endif diff -pNur xorg-server-1.4.orig/hw/vnc/rfbproto.h xorg-server-1.4/hw/vnc/rfbproto.h --- xorg-server-1.4.orig/hw/vnc/rfbproto.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rfbproto.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,1362 @@ +/* + * Copyright (C) 2000-2004 Constantin Kaplinsky. All Rights Reserved. + * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * rfbproto.h - header file for the RFB protocol, versions 3.3, 3.7 and 3.7t + * (protocol 3.7t is effectively 3.7 with TightVNC extensions enabled) + * + * Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed + * integer (for n = 8, 16 and 32). + * + * All multiple byte integers are in big endian (network) order (most + * significant byte first). Unless noted otherwise there is no special + * alignment of protocol structures. + * + * + * Once the initial handshaking is done, all messages start with a type byte, + * (usually) followed by message-specific data. The order of definitions in + * this file is as follows: + * + * (1) Structures used in several types of message. + * (2) Structures used in the initial handshaking. + * (3) Message types. + * (4) Encoding types. + * (5) For each message type, the form of the data following the type byte. + * Sometimes this is defined by a single structure but the more complex + * messages have to be explained by comments. + */ + + +/***************************************************************************** + * + * Structures used in several messages + * + *****************************************************************************/ + +/*----------------------------------------------------------------------------- + * Structure used to specify a rectangle. This structure is a multiple of 4 + * bytes so that it can be interspersed with 32-bit pixel data without + * affecting alignment. + */ + +typedef struct _rfbRectangle { + CARD16 x; + CARD16 y; + CARD16 w; + CARD16 h; +} rfbRectangle; + +#define sz_rfbRectangle 8 + + +/*----------------------------------------------------------------------------- + * Structure used to specify pixel format. + */ + +typedef struct _rfbPixelFormat { + + CARD8 bitsPerPixel; /* 8,16,32 only */ + + CARD8 depth; /* 8 to 32 */ + + CARD8 bigEndian; /* True if multi-byte pixels are interpreted + as big endian, or if single-bit-per-pixel + has most significant bit of the byte + corresponding to first (leftmost) pixel. Of + course this is meaningless for 8 bits/pix */ + + CARD8 trueColour; /* If false then we need a "colour map" to + convert pixels to RGB. If true, xxxMax and + xxxShift specify bits used for red, green + and blue */ + + /* the following fields are only meaningful if trueColour is true */ + + CARD16 redMax; /* maximum red value (= 2^n - 1 where n is the + number of bits used for red). Note this + value is always in big endian order. */ + + CARD16 greenMax; /* similar for green */ + + CARD16 blueMax; /* and blue */ + + CARD8 redShift; /* number of shifts needed to get the red + value in a pixel to the least significant + bit. To find the red value from a given + pixel, do the following: + 1) Swap pixel value according to bigEndian + (e.g. if bigEndian is false and host byte + order is big endian, then swap). + 2) Shift right by redShift. + 3) AND with redMax (in host byte order). + 4) You now have the red value between 0 and + redMax. */ + + CARD8 greenShift; /* similar for green */ + + CARD8 blueShift; /* and blue */ + + CARD8 pad1; + CARD16 pad2; + +} rfbPixelFormat; + +#define sz_rfbPixelFormat 16 + + +/*----------------------------------------------------------------------------- + * Structure used to describe protocol options such as tunneling methods, + * authentication schemes and message types (protocol version 3.7t). + */ + +typedef struct _rfbCapabilityInfo { + + CARD32 code; /* numeric identifier */ + CARD8 vendorSignature[4]; /* vendor identification */ + CARD8 nameSignature[8]; /* abbreviated option name */ + +} rfbCapabilityInfo; + +#define sz_rfbCapabilityInfoVendor 4 +#define sz_rfbCapabilityInfoName 8 +#define sz_rfbCapabilityInfo 16 + +/* + * Vendors known by TightVNC: standard VNC/RealVNC, TridiaVNC, and TightVNC. + */ + +#define rfbStandardVendor "STDV" +#define rfbTridiaVncVendor "TRDV" +#define rfbTightVncVendor "TGHT" +#define rfbTungstenGraphicsVendor "TGIV" + + +/***************************************************************************** + * + * Initial handshaking messages + * + *****************************************************************************/ + +/*----------------------------------------------------------------------------- + * Protocol Version + * + * The server always sends 12 bytes to start which identifies the latest RFB + * protocol version number which it supports. These bytes are interpreted + * as a string of 12 ASCII characters in the format "RFB xxx.yyy\n" where + * xxx and yyy are the major and minor version numbers (for version 3.7 + * this is "RFB 003.007\n"). + * + * The client then replies with a similar 12-byte message giving the version + * number of the protocol which should actually be used (which may be different + * to that quoted by the server). + * + * It is intended that both clients and servers may provide some level of + * backwards compatibility by this mechanism. Servers in particular should + * attempt to provide backwards compatibility, and even forwards compatibility + * to some extent. For example if a client demands version 3.1 of the + * protocol, a 3.0 server can probably assume that by ignoring requests for + * encoding types it doesn't understand, everything will still work OK. This + * will probably not be the case for changes in the major version number. + * + * The format string below can be used in sprintf or sscanf to generate or + * decode the version string respectively. + */ + +#define rfbProtocolVersionFormat "RFB %03d.%03d\n" +#define rfbProtocolMajorVersion 3 +#define rfbProtocolMinorVersion 7 +#define rfbProtocolFallbackMinorVersion 3 + +typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */ + +#define sz_rfbProtocolVersionMsg 12 + + +/* + * Negotiation of the security type (protocol version 3.7) + * + * Once the protocol version has been decided, the server either sends a list + * of supported security types, or informs the client about an error (when the + * number of security types is 0). Security type rfbSecTypeTight is used to + * enable TightVNC-specific protocol extensions. The value rfbSecTypeVncAuth + * stands for classic VNC authentication. + * + * The client selects a particular security type from the list provided by the + * server. + */ + +#define rfbSecTypeInvalid 0 +#define rfbSecTypeNone 1 +#define rfbSecTypeVncAuth 2 +#define rfbSecTypeTight 16 + + +/*----------------------------------------------------------------------------- + * Negotiation of Tunneling Capabilities (protocol version 3.7t) + * + * If the chosen security type is rfbSecTypeTight, the server sends a list of + * supported tunneling methods ("tunneling" refers to any additional layer of + * data transformation, such as encryption or external compression.) + * + * nTunnelTypes specifies the number of following rfbCapabilityInfo structures + * that list all supported tunneling methods in the order of preference. + * + * NOTE: If nTunnelTypes is 0, that tells the client that no tunneling can be + * used, and the client should not send a response requesting a tunneling + * method. + */ + +typedef struct _rfbTunnelingCapsMsg { + CARD32 nTunnelTypes; + /* followed by nTunnelTypes * rfbCapabilityInfo structures */ +} rfbTunnelingCapsMsg; + +#define sz_rfbTunnelingCapsMsg 4 + +/*----------------------------------------------------------------------------- + * Tunneling Method Request (protocol version 3.7t) + * + * If the list of tunneling capabilities sent by the server was not empty, the + * client should reply with a 32-bit code specifying a particular tunneling + * method. The following code should be used for no tunneling. + */ + +#define rfbNoTunneling 0 +#define sig_rfbNoTunneling "NOTUNNEL" + + +/*----------------------------------------------------------------------------- + * Negotiation of Authentication Capabilities (protocol version 3.7t) + * + * After setting up tunneling, the server sends a list of supported + * authentication schemes. + * + * nAuthTypes specifies the number of following rfbCapabilityInfo structures + * that list all supported authentication schemes in the order of preference. + * + * NOTE: If nAuthTypes is 0, that tells the client that no authentication is + * necessary, and the client should not send a response requesting an + * authentication scheme. + */ + +typedef struct _rfbAuthenticationCapsMsg { + CARD32 nAuthTypes; + /* followed by nAuthTypes * rfbCapabilityInfo structures */ +} rfbAuthenticationCapsMsg; + +#define sz_rfbAuthenticationCapsMsg 4 + +/*----------------------------------------------------------------------------- + * Authentication Scheme Request (protocol version 3.7t) + * + * If the list of authentication capabilities sent by the server was not empty, + * the client should reply with a 32-bit code specifying a particular + * authentication scheme. The following codes are supported. + */ + +#define rfbAuthNone 1 +#define rfbAuthVNC 2 +#define rfbAuthUnixLogin 129 +#define rfbAuthExternal 130 + +#define sig_rfbAuthNone "NOAUTH__" +#define sig_rfbAuthVNC "VNCAUTH_" +#define sig_rfbAuthUnixLogin "ULGNAUTH" +#define sig_rfbAuthExternal "XTRNAUTH" + + +/*----------------------------------------------------------------------------- + * Standard VNC Authentication (all protocol versions) + * + * Standard authentication result codes are defined below. + */ + +#define rfbVncAuthOK 0 +#define rfbVncAuthFailed 1 +#define rfbVncAuthTooMany 2 + + +/*----------------------------------------------------------------------------- + * Client Initialisation Message + * + * Once the client and server are sure that they're happy to talk to one + * another, the client sends an initialisation message. At present this + * message only consists of a boolean indicating whether the server should try + * to share the desktop by leaving other clients connected, or give exclusive + * access to this client by disconnecting all other clients. + */ + +typedef struct _rfbClientInitMsg { + CARD8 shared; +} rfbClientInitMsg; + +#define sz_rfbClientInitMsg 1 + + +/*----------------------------------------------------------------------------- + * Server Initialisation Message + * + * After the client initialisation message, the server sends one of its own. + * This tells the client the width and height of the server's framebuffer, + * its pixel format and the name associated with the desktop. + */ + +typedef struct _rfbServerInitMsg { + CARD16 framebufferWidth; + CARD16 framebufferHeight; + rfbPixelFormat format; /* the server's preferred pixel format */ + CARD32 nameLength; + /* followed by char name[nameLength] */ +} rfbServerInitMsg; + +#define sz_rfbServerInitMsg (8 + sz_rfbPixelFormat) + + +/*----------------------------------------------------------------------------- + * Server Interaction Capabilities Message (protocol version 3.7t) + * + * In the protocol version 3.7t, the server informs the client what message + * types it supports in addition to ones defined in the protocol version 3.7. + * Also, the server sends the list of all supported encodings (note that it's + * not necessary to advertise the "raw" encoding sinse it MUST be supported in + * RFB 3.x protocols). + * + * This data immediately follows the server initialisation message. + */ + +typedef struct _rfbInteractionCapsMsg { + CARD16 nServerMessageTypes; + CARD16 nClientMessageTypes; + CARD16 nEncodingTypes; + CARD16 pad; /* reserved, must be 0 */ + /* followed by nServerMessageTypes * rfbCapabilityInfo structures */ + /* followed by nClientMessageTypes * rfbCapabilityInfo structures */ +} rfbInteractionCapsMsg; + +#define sz_rfbInteractionCapsMsg 8 + + +/* + * Following the server initialisation message it's up to the client to send + * whichever protocol messages it wants. Typically it will send a + * SetPixelFormat message and a SetEncodings message, followed by a + * FramebufferUpdateRequest. From then on the server will send + * FramebufferUpdate messages in response to the client's + * FramebufferUpdateRequest messages. The client should send + * FramebufferUpdateRequest messages with incremental set to true when it has + * finished processing one FramebufferUpdate and is ready to process another. + * With a fast client, the rate at which FramebufferUpdateRequests are sent + * should be regulated to avoid hogging the network. + */ + + + +/***************************************************************************** + * + * Message types + * + *****************************************************************************/ + +/* server -> client */ + +#define rfbFramebufferUpdate 0 +#define rfbSetColourMapEntries 1 +#define rfbBell 2 +#define rfbServerCutText 3 +/* Chromium extensions, use higher values */ +#define rfbChromiumStart 50 +#define rfbChromiumMoveResizeWindow 51 +#define rfbChromiumClipList 52 +#define rfbChromiumWindowShow 53 +#define rfbChromiumWindowDestroy 54 + +#define rfbFileListData 130 +#define rfbFileDownloadData 131 +#define rfbFileUploadCancel 132 +#define rfbFileDownloadFailed 133 + +/* signatures for non-standard messages */ +#define sig_rfbFileListData "FTS_LSDT" +#define sig_rfbFileDownloadData "FTS_DNDT" +#define sig_rfbFileUploadCancel "FTS_UPCN" +#define sig_rfbFileDownloadFailed "FTS_DNFL" + + +/* client -> server */ + +#define rfbSetPixelFormat 0 +#define rfbFixColourMapEntries 1 /* not currently supported */ +#define rfbSetEncodings 2 +#define rfbFramebufferUpdateRequest 3 +#define rfbKeyEvent 4 +#define rfbPointerEvent 5 +#define rfbClientCutText 6 +/* Chromium extensions, use higher values */ +#define rfbChromiumStop 50 +#define rfbChromiumExpose 51 + +#define rfbFileListRequest 130 +#define rfbFileDownloadRequest 131 +#define rfbFileUploadRequest 132 +#define rfbFileUploadData 133 +#define rfbFileDownloadCancel 134 +#define rfbFileUploadFailed 135 +#define rfbFileCreateDirRequest 136 + +/* signatures for non-standard messages */ +#define sig_rfbFileListRequest "FTC_LSRQ" +#define sig_rfbFileDownloadRequest "FTC_DNRQ" +#define sig_rfbFileUploadRequest "FTC_UPRQ" +#define sig_rfbFileUploadData "FTC_UPDT" +#define sig_rfbFileDownloadCancel "FTC_DNCN" +#define sig_rfbFileUploadFailed "FTC_UPFL" +#define sig_rfbFileCreateDirRequest "FTC_FCDR" + +/***************************************************************************** + * + * Encoding types + * + *****************************************************************************/ + +#define rfbEncodingRaw 0 +#define rfbEncodingCopyRect 1 +#define rfbEncodingRRE 2 +#define rfbEncodingCoRRE 4 +#define rfbEncodingHextile 5 +#define rfbEncodingZlib 6 +#define rfbEncodingTight 7 +#define rfbEncodingZlibHex 8 + +/* signatures for basic encoding types */ +#define sig_rfbEncodingRaw "RAW_____" +#define sig_rfbEncodingCopyRect "COPYRECT" +#define sig_rfbEncodingRRE "RRE_____" +#define sig_rfbEncodingCoRRE "CORRE___" +#define sig_rfbEncodingHextile "HEXTILE_" +#define sig_rfbEncodingZlib "ZLIB____" +#define sig_rfbEncodingTight "TIGHT___" +#define sig_rfbEncodingZlibHex "ZLIBHEX_" +#define sig_rfbEncodingChromium "CHROMIUM" + +/* + * Special encoding numbers: + * 0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels; + * 0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data; + * 0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions; + * 0xFFFFFF30 .. 0xFFFFFFDF -- not allocated yet; + * 0xFFFFFFE0 .. 0xFFFFFFEF -- quality level for JPEG compressor; + * 0xFFFFFFF0 .. 0xFFFFFFFF -- not allocated yet. + */ + +#define rfbEncodingCompressLevel0 0xFFFFFF00 +#define rfbEncodingCompressLevel1 0xFFFFFF01 +#define rfbEncodingCompressLevel2 0xFFFFFF02 +#define rfbEncodingCompressLevel3 0xFFFFFF03 +#define rfbEncodingCompressLevel4 0xFFFFFF04 +#define rfbEncodingCompressLevel5 0xFFFFFF05 +#define rfbEncodingCompressLevel6 0xFFFFFF06 +#define rfbEncodingCompressLevel7 0xFFFFFF07 +#define rfbEncodingCompressLevel8 0xFFFFFF08 +#define rfbEncodingCompressLevel9 0xFFFFFF09 + +#define rfbEncodingXCursor 0xFFFFFF10 +#define rfbEncodingRichCursor 0xFFFFFF11 +#define rfbEncodingPointerPos 0xFFFFFF18 + +#define rfbEncodingLastRect 0xFFFFFF20 +#define rfbEncodingNewFBSize 0xFFFFFF21 +#define rfbEncodingChromium 0xFFFFFF2F +#define rfbEncodingChromium2 0xFFFFFF30 + +#define rfbEncodingQualityLevel0 0xFFFFFFE0 +#define rfbEncodingQualityLevel1 0xFFFFFFE1 +#define rfbEncodingQualityLevel2 0xFFFFFFE2 +#define rfbEncodingQualityLevel3 0xFFFFFFE3 +#define rfbEncodingQualityLevel4 0xFFFFFFE4 +#define rfbEncodingQualityLevel5 0xFFFFFFE5 +#define rfbEncodingQualityLevel6 0xFFFFFFE6 +#define rfbEncodingQualityLevel7 0xFFFFFFE7 +#define rfbEncodingQualityLevel8 0xFFFFFFE8 +#define rfbEncodingQualityLevel9 0xFFFFFFE9 + +/* signatures for "fake" encoding types */ +#define sig_rfbEncodingCompressLevel0 "COMPRLVL" +#define sig_rfbEncodingXCursor "X11CURSR" +#define sig_rfbEncodingRichCursor "RCHCURSR" +#define sig_rfbEncodingPointerPos "POINTPOS" +#define sig_rfbEncodingLastRect "LASTRECT" +#define sig_rfbEncodingNewFBSize "NEWFBSIZ" +#define sig_rfbEncodingQualityLevel0 "JPEGQLVL" + + +/***************************************************************************** + * + * Server -> client message definitions + * + *****************************************************************************/ + + +/*----------------------------------------------------------------------------- + * FramebufferUpdate - a block of rectangles to be copied to the framebuffer. + * + * This message consists of a header giving the number of rectangles of pixel + * data followed by the rectangles themselves. The header is padded so that + * together with the type byte it is an exact multiple of 4 bytes (to help + * with alignment of 32-bit pixels): + */ + +typedef struct _rfbFramebufferUpdateMsg { + CARD8 type; /* always rfbFramebufferUpdate */ + CARD8 pad; + CARD16 nRects; + /* followed by nRects rectangles */ +} rfbFramebufferUpdateMsg; + +#define sz_rfbFramebufferUpdateMsg 4 + +/* + * Each rectangle of pixel data consists of a header describing the position + * and size of the rectangle and a type word describing the encoding of the + * pixel data, followed finally by the pixel data. Note that if the client has + * not sent a SetEncodings message then it will only receive raw pixel data. + * Also note again that this structure is a multiple of 4 bytes. + */ + +typedef struct _rfbFramebufferUpdateRectHeader { + rfbRectangle r; + CARD32 encoding; /* one of the encoding types rfbEncoding... */ +} rfbFramebufferUpdateRectHeader; + +#define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4) + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * Raw Encoding. Pixels are sent in top-to-bottom scanline order, + * left-to-right within a scanline with no padding in between. + */ + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * CopyRect Encoding. The pixels are specified simply by the x and y position + * of the source rectangle. + */ + +typedef struct _rfbCopyRect { + CARD16 srcX; + CARD16 srcY; +} rfbCopyRect; + +#define sz_rfbCopyRect 4 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * RRE - Rise-and-Run-length Encoding. We have an rfbRREHeader structure + * giving the number of subrectangles following. Finally the data follows in + * the form [<bgpixel><subrect><subrect>...] where each <subrect> is + * [<pixel><rfbRectangle>]. + */ + +typedef struct _rfbRREHeader { + CARD32 nSubrects; +} rfbRREHeader; + +#define sz_rfbRREHeader 4 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * CoRRE - Compact RRE Encoding. We have an rfbRREHeader structure giving + * the number of subrectangles following. Finally the data follows in the form + * [<bgpixel><subrect><subrect>...] where each <subrect> is + * [<pixel><rfbCoRRERectangle>]. This means that + * the whole rectangle must be at most 255x255 pixels. + */ + +typedef struct _rfbCoRRERectangle { + CARD8 x; + CARD8 y; + CARD8 w; + CARD8 h; +} rfbCoRRERectangle; + +#define sz_rfbCoRRERectangle 4 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * Hextile Encoding. The rectangle is divided up into "tiles" of 16x16 pixels, + * starting at the top left going in left-to-right, top-to-bottom order. If + * the width of the rectangle is not an exact multiple of 16 then the width of + * the last tile in each row will be correspondingly smaller. Similarly if the + * height is not an exact multiple of 16 then the height of each tile in the + * final row will also be smaller. Each tile begins with a "subencoding" type + * byte, which is a mask made up of a number of bits. If the Raw bit is set + * then the other bits are irrelevant; w*h pixel values follow (where w and h + * are the width and height of the tile). Otherwise the tile is encoded in a + * similar way to RRE, except that the position and size of each subrectangle + * can be specified in just two bytes. The other bits in the mask are as + * follows: + * + * BackgroundSpecified - if set, a pixel value follows which specifies + * the background colour for this tile. The first non-raw tile in a + * rectangle must have this bit set. If this bit isn't set then the + * background is the same as the last tile. + * + * ForegroundSpecified - if set, a pixel value follows which specifies + * the foreground colour to be used for all subrectangles in this tile. + * If this bit is set then the SubrectsColoured bit must be zero. + * + * AnySubrects - if set, a single byte follows giving the number of + * subrectangles following. If not set, there are no subrectangles (i.e. + * the whole tile is just solid background colour). + * + * SubrectsColoured - if set then each subrectangle is preceded by a pixel + * value giving the colour of that subrectangle. If not set, all + * subrectangles are the same colour, the foreground colour; if the + * ForegroundSpecified bit wasn't set then the foreground is the same as + * the last tile. + * + * The position and size of each subrectangle is specified in two bytes. The + * Pack macros below can be used to generate the two bytes from x, y, w, h, + * and the Extract macros can be used to extract the x, y, w, h values from + * the two bytes. + */ + +#define rfbHextileRaw (1 << 0) +#define rfbHextileBackgroundSpecified (1 << 1) +#define rfbHextileForegroundSpecified (1 << 2) +#define rfbHextileAnySubrects (1 << 3) +#define rfbHextileSubrectsColoured (1 << 4) + +#define rfbHextilePackXY(x,y) (((x) << 4) | (y)) +#define rfbHextilePackWH(w,h) ((((w)-1) << 4) | ((h)-1)) +#define rfbHextileExtractX(byte) ((byte) >> 4) +#define rfbHextileExtractY(byte) ((byte) & 0xf) +#define rfbHextileExtractW(byte) (((byte) >> 4) + 1) +#define rfbHextileExtractH(byte) (((byte) & 0xf) + 1) + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * ZLIB - zlib compression Encoding. We have an rfbZlibHeader structure + * giving the number of bytes to follow. Finally the data follows in + * zlib compressed format. + */ + +typedef struct _rfbZlibHeader { + CARD32 nBytes; +} rfbZlibHeader; + +#define sz_rfbZlibHeader 4 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * Tight Encoding. + * + *-- The first byte of each Tight-encoded rectangle is a "compression control + * byte". Its format is as follows (bit 0 is the least significant one): + * + * bit 0: if 1, then compression stream 0 should be reset; + * bit 1: if 1, then compression stream 1 should be reset; + * bit 2: if 1, then compression stream 2 should be reset; + * bit 3: if 1, then compression stream 3 should be reset; + * bits 7-4: if 1000 (0x08), then the compression type is "fill", + * if 1001 (0x09), then the compression type is "jpeg", + * if 0xxx, then the compression type is "basic", + * values greater than 1001 are not valid. + * + * If the compression type is "basic", then bits 6..4 of the + * compression control byte (those xxx in 0xxx) specify the following: + * + * bits 5-4: decimal representation is the index of a particular zlib + * stream which should be used for decompressing the data; + * bit 6: if 1, then a "filter id" byte is following this byte. + * + *-- The data that follows after the compression control byte described + * above depends on the compression type ("fill", "jpeg" or "basic"). + * + *-- If the compression type is "fill", then the only pixel value follows, in + * client pixel format (see NOTE 1). This value applies to all pixels of the + * rectangle. + * + *-- If the compression type is "jpeg", the following data stream looks like + * this: + * + * 1..3 bytes: data size (N) in compact representation; + * N bytes: JPEG image. + * + * Data size is compactly represented in one, two or three bytes, according + * to the following scheme: + * + * 0xxxxxxx (for values 0..127) + * 1xxxxxxx 0yyyyyyy (for values 128..16383) + * 1xxxxxxx 1yyyyyyy zzzzzzzz (for values 16384..4194303) + * + * Here each character denotes one bit, xxxxxxx are the least significant 7 + * bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the + * most significant 8 bits (bits 14-21). For example, decimal value 10000 + * should be represented as two bytes: binary 10010000 01001110, or + * hexadecimal 90 4E. + * + *-- If the compression type is "basic" and bit 6 of the compression control + * byte was set to 1, then the next (second) byte specifies "filter id" which + * tells the decoder what filter type was used by the encoder to pre-process + * pixel data before the compression. The "filter id" byte can be one of the + * following: + * + * 0: no filter ("copy" filter); + * 1: "palette" filter; + * 2: "gradient" filter. + * + *-- If bit 6 of the compression control byte is set to 0 (no "filter id" + * byte), or if the filter id is 0, then raw pixel values in the client + * format (see NOTE 1) will be compressed. See below details on the + * compression. + * + *-- The "gradient" filter pre-processes pixel data with a simple algorithm + * which converts each color component to a difference between a "predicted" + * intensity and the actual intensity. Such a technique does not affect + * uncompressed data size, but helps to compress photo-like images better. + * Pseudo-code for converting intensities to differences is the following: + * + * P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1]; + * if (P[i,j] < 0) then P[i,j] := 0; + * if (P[i,j] > MAX) then P[i,j] := MAX; + * D[i,j] := V[i,j] - P[i,j]; + * + * Here V[i,j] is the intensity of a color component for a pixel at + * coordinates (i,j). MAX is the maximum value of intensity for a color + * component. + * + *-- The "palette" filter converts true-color pixel data to indexed colors + * and a palette which can consist of 2..256 colors. If the number of colors + * is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to + * encode one pixel. 1-bit encoding is performed such way that the most + * significant bits correspond to the leftmost pixels, and each raw of pixels + * is aligned to the byte boundary. When "palette" filter is used, the + * palette is sent before the pixel data. The palette begins with an unsigned + * byte which value is the number of colors in the palette minus 1 (i.e. 1 + * means 2 colors, 255 means 256 colors in the palette). Then follows the + * palette itself which consist of pixel values in client pixel format (see + * NOTE 1). + * + *-- The pixel data is compressed using the zlib library. But if the data + * size after applying the filter but before the compression is less then 12, + * then the data is sent as is, uncompressed. Four separate zlib streams + * (0..3) can be used and the decoder should read the actual stream id from + * the compression control byte (see NOTE 2). + * + * If the compression is not used, then the pixel data is sent as is, + * otherwise the data stream looks like this: + * + * 1..3 bytes: data size (N) in compact representation; + * N bytes: zlib-compressed data. + * + * Data size is compactly represented in one, two or three bytes, just like + * in the "jpeg" compression method (see above). + * + *-- NOTE 1. If the color depth is 24, and all three color components are + * 8-bit wide, then one pixel in Tight encoding is always represented by + * three bytes, where the first byte is red component, the second byte is + * green component, and the third byte is blue component of the pixel color + * value. This applies to colors in palettes as well. + * + *-- NOTE 2. The decoder must reset compression streams' states before + * decoding the rectangle, if some of bits 0,1,2,3 in the compression control + * byte are set to 1. Note that the decoder must reset zlib streams even if + * the compression type is "fill" or "jpeg". + * + *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only + * when bits-per-pixel value is either 16 or 32, not 8. + * + *-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048 + * pixels. If a rectangle is wider, it must be split into several rectangles + * and each one should be encoded separately. + * + */ + +#define rfbTightExplicitFilter 0x04 +#define rfbTightFill 0x08 +#define rfbTightJpeg 0x09 +#define rfbTightMaxSubencoding 0x09 + +/* Filters to improve compression efficiency */ +#define rfbTightFilterCopy 0x00 +#define rfbTightFilterPalette 0x01 +#define rfbTightFilterGradient 0x02 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * ZLIBHEX - zlib compressed Hextile Encoding. Essentially, this is the + * hextile encoding with zlib compression on the tiles that can not be + * efficiently encoded with one of the other hextile subencodings. The + * new zlib subencoding uses two bytes to specify the length of the + * compressed tile and then the compressed data follows. As with the + * raw sub-encoding, the zlib subencoding invalidates the other + * values, if they are also set. + */ + +#define rfbHextileZlibRaw (1 << 5) +#define rfbHextileZlibHex (1 << 6) + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * XCursor encoding. This is a special encoding used to transmit X-style + * cursor shapes from server to clients. Note that for this encoding, + * coordinates in rfbFramebufferUpdateRectHeader structure hold hotspot + * position (r.x, r.y) and cursor size (r.w, r.h). If (w * h != 0), two RGB + * samples are sent after header in the rfbXCursorColors structure. They + * denote foreground and background colors of the cursor. If a client + * supports only black-and-white cursors, it should ignore these colors and + * assume that foreground is black and background is white. Next, two bitmaps + * (1 bits per pixel) follow: first one with actual data (value 0 denotes + * background color, value 1 denotes foreground color), second one with + * transparency data (bits with zero value mean that these pixels are + * transparent). Both bitmaps represent cursor data in a byte stream, from + * left to right, from top to bottom, and each row is byte-aligned. Most + * significant bits correspond to leftmost pixels. The number of bytes in + * each row can be calculated as ((w + 7) / 8). If (w * h == 0), cursor + * should be hidden (or default local cursor should be set by the client). + */ + +typedef struct _rfbXCursorColors { + CARD8 foreRed; + CARD8 foreGreen; + CARD8 foreBlue; + CARD8 backRed; + CARD8 backGreen; + CARD8 backBlue; +} rfbXCursorColors; + +#define sz_rfbXCursorColors 6 + + +/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + * RichCursor encoding. This is a special encoding used to transmit cursor + * shapes from server to clients. It is similar to the XCursor encoding but + * uses client pixel format instead of two RGB colors to represent cursor + * image. For this encoding, coordinates in rfbFramebufferUpdateRectHeader + * structure hold hotspot position (r.x, r.y) and cursor size (r.w, r.h). + * After header, two pixmaps follow: first one with cursor image in current + * client pixel format (like in raw encoding), second with transparency data + * (1 bit per pixel, exactly the same format as used for transparency bitmap + * in the XCursor encoding). If (w * h == 0), cursor should be hidden (or + * default local cursor should be set by the client). + */ + + +/*----------------------------------------------------------------------------- + * SetColourMapEntries - these messages are only sent if the pixel + * format uses a "colour map" (i.e. trueColour false) and the client has not + * fixed the entire colour map using FixColourMapEntries. In addition they + * will only start being sent after the client has sent its first + * FramebufferUpdateRequest. So if the client always tells the server to use + * trueColour then it never needs to process this type of message. + */ + +typedef struct _rfbSetColourMapEntriesMsg { + CARD8 type; /* always rfbSetColourMapEntries */ + CARD8 redIndex; /* used to be pad, but used for DirectColor */ + CARD16 firstColour; + CARD16 nColours; + + /* Followed by nColours * 3 * CARD16 + r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ + +} rfbSetColourMapEntriesMsg; + +#define sz_rfbSetColourMapEntriesMsg 6 + + + +/*----------------------------------------------------------------------------- + * Bell - ring a bell on the client if it has one. + */ + +typedef struct _rfbBellMsg { + CARD8 type; /* always rfbBell */ +} rfbBellMsg; + +#define sz_rfbBellMsg 1 + + + +/*----------------------------------------------------------------------------- + * ServerCutText - the server has new text in its cut buffer. + */ + +typedef struct _rfbServerCutTextMsg { + CARD8 type; /* always rfbServerCutText */ + CARD8 pad1; + CARD16 pad2; + CARD32 length; + /* followed by char text[length] */ +} rfbServerCutTextMsg; + +#define sz_rfbServerCutTextMsg 8 + +/*----------------------------------------------------------------------------- + * ChromiumStart - a port number for the crserver + */ + +typedef struct { + CARD8 type; /* always rfbChromiumStart */ + CARD8 pad1; + CARD16 pad2; + CARD32 crServerPort; + CARD32 mothershipPort; +} rfbChromiumStartMsg; + +#define sz_rfbChromiumStartMsg 12 + + +/*----------------------------------------------------------------------------- + * ChromiumMoveResizeWindow - move a chromium window + */ + +typedef struct { + CARD8 type; /* always rfbChromiumMoveResizeWindow */ + CARD8 pad1; + CARD16 pad2; + CARD32 winid; + CARD32 x; + CARD32 y; + CARD32 w; + CARD32 h; +} rfbChromiumMoveResizeWindowMsg; + +#define sz_rfbChromiumMoveResizeWindowMsg 24 + +/*----------------------------------------------------------------------------- + * ChromiumClipList - send clip list + */ + +typedef struct { + CARD8 type; /* always rfbChromiumClipList */ + CARD8 pad1; + CARD16 pad2; + CARD32 winid; + CARD32 length; +} rfbChromiumClipListMsg; + +#define sz_rfbChromiumClipListMsg 12 + +/*----------------------------------------------------------------------------- + * ChromiumWindowShow - map or unmap a window + */ + +typedef struct { + CARD8 type; /* always rfbChromiumWindowShow */ + CARD8 pad1; + CARD16 pad2; + CARD32 winid; + CARD32 show; +} rfbChromiumWindowShowMsg; + +#define sz_rfbChromiumWindowShowMsg 12 + +/*----------------------------------------------------------------------------- + * ChromiumWindowDestroy - destroy a window + */ + +typedef struct { + CARD8 type; /* always rfbChromiumWindowDestroy */ + CARD8 pad1; + CARD16 pad2; + CARD32 winid; +} rfbChromiumWindowDestroyMsg; + +#define sz_rfbChromiumWindowDestroyMsg 8 + +/*----------------------------------------------------------------------------- + * FileListData + */ + +typedef struct _rfbFileListDataMsg { + CARD8 type; + CARD8 flags; + CARD16 numFiles; + CARD16 dataSize; + CARD16 compressedSize; + /* Followed by SizeData[numFiles] */ + /* Followed by Filenames[compressedSize] */ +} rfbFileListDataMsg; + +#define sz_rfbFileListDataMsg 8 + +/*----------------------------------------------------------------------------- + * FileDownloadData + */ + +typedef struct _rfbFileDownloadDataMsg { + CARD8 type; + CARD8 compressLevel; + CARD16 realSize; + CARD16 compressedSize; + /* Followed by File[copressedSize] */ +} rfbFileDownloadDataMsg; + +#define sz_rfbFileDownloadDataMsg 6 + + +/*----------------------------------------------------------------------------- + * FileUploadCancel + */ + +typedef struct _rfbFileUploadCancelMsg { + CARD8 type; + CARD8 unused; + CARD16 reasonLen; + /* Followed by reason[reasonLen] */ +} rfbFileUploadCancelMsg; + +#define sz_rfbFileUploadCancelMsg 4 + +/*----------------------------------------------------------------------------- + * FileDownloadFailed + */ + +typedef struct _rfbFileDownloadFailedMsg { + CARD8 type; + CARD8 unused; + CARD16 reasonLen; + /* Followed by reason[reasonLen] */ +} rfbFileDownloadFailedMsg; + +#define sz_rfbFileDownloadFailedMsg 4 + +/*----------------------------------------------------------------------------- + * Union of all server->client messages. + */ + +typedef union _rfbServerToClientMsg { + CARD8 type; + rfbFramebufferUpdateMsg fu; + rfbSetColourMapEntriesMsg scme; + rfbBellMsg b; + rfbServerCutTextMsg sct; + rfbFileListDataMsg fld; + rfbFileDownloadDataMsg fdd; + rfbFileUploadCancelMsg fuc; + rfbFileDownloadFailedMsg fdf; + rfbChromiumStartMsg scd; + rfbChromiumMoveResizeWindowMsg scm; + rfbChromiumClipListMsg sccl; + rfbChromiumWindowShowMsg scws; + rfbChromiumWindowDestroyMsg scwd; +} rfbServerToClientMsg; + + + +/***************************************************************************** + * + * Message definitions (client -> server) + * + *****************************************************************************/ + + +/*----------------------------------------------------------------------------- + * SetPixelFormat - tell the RFB server the format in which the client wants + * pixels sent. + */ + +typedef struct _rfbSetPixelFormatMsg { + CARD8 type; /* always rfbSetPixelFormat */ + CARD8 pad1; + CARD16 pad2; + rfbPixelFormat format; +} rfbSetPixelFormatMsg; + +#define sz_rfbSetPixelFormatMsg (sz_rfbPixelFormat + 4) + + +/*----------------------------------------------------------------------------- + * FixColourMapEntries - when the pixel format uses a "colour map", fix + * read-only colour map entries. + * + * ***************** NOT CURRENTLY SUPPORTED ***************** + */ + +typedef struct _rfbFixColourMapEntriesMsg { + CARD8 type; /* always rfbFixColourMapEntries */ + CARD8 pad; + CARD16 firstColour; + CARD16 nColours; + + /* Followed by nColours * 3 * CARD16 + r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ + +} rfbFixColourMapEntriesMsg; + +#define sz_rfbFixColourMapEntriesMsg 6 + + +/*----------------------------------------------------------------------------- + * SetEncodings - tell the RFB server which encoding types we accept. Put them + * in order of preference, if we have any. We may always receive raw + * encoding, even if we don't specify it here. + */ + +typedef struct _rfbSetEncodingsMsg { + CARD8 type; /* always rfbSetEncodings */ + CARD8 pad; + CARD16 nEncodings; + /* followed by nEncodings * CARD32 encoding types */ +} rfbSetEncodingsMsg; + +#define sz_rfbSetEncodingsMsg 4 + + +/*----------------------------------------------------------------------------- + * FramebufferUpdateRequest - request for a framebuffer update. If incremental + * is true then the client just wants the changes since the last update. If + * false then it wants the whole of the specified rectangle. + */ + +typedef struct _rfbFramebufferUpdateRequestMsg { + CARD8 type; /* always rfbFramebufferUpdateRequest */ + CARD8 incremental; + CARD16 x; + CARD16 y; + CARD16 w; + CARD16 h; +} rfbFramebufferUpdateRequestMsg; + +#define sz_rfbFramebufferUpdateRequestMsg 10 + + +/*----------------------------------------------------------------------------- + * KeyEvent - key press or release + * + * Keys are specified using the "keysym" values defined by the X Window System. + * For most ordinary keys, the keysym is the same as the corresponding ASCII + * value. Other common keys are: + * + * BackSpace 0xff08 + * Tab 0xff09 + * Return or Enter 0xff0d + * Escape 0xff1b + * Insert 0xff63 + * Delete 0xffff + * Home 0xff50 + * End 0xff57 + * Page Up 0xff55 + * Page Down 0xff56 + * Left 0xff51 + * Up 0xff52 + * Right 0xff53 + * Down 0xff54 + * F1 0xffbe + * F2 0xffbf + * ... ... + * F12 0xffc9 + * Shift 0xffe1 + * Control 0xffe3 + * Meta 0xffe7 + * Alt 0xffe9 + */ + +typedef struct _rfbKeyEventMsg { + CARD8 type; /* always rfbKeyEvent */ + CARD8 down; /* true if down (press), false if up */ + CARD16 pad; + CARD32 key; /* key is specified as an X keysym */ +} rfbKeyEventMsg; + +#define sz_rfbKeyEventMsg 8 + + +/*----------------------------------------------------------------------------- + * PointerEvent - mouse/pen move and/or button press. + */ + +typedef struct _rfbPointerEventMsg { + CARD8 type; /* always rfbPointerEvent */ + CARD8 buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */ + CARD16 x; + CARD16 y; +} rfbPointerEventMsg; + +#define rfbButton1Mask 1 +#define rfbButton2Mask 2 +#define rfbButton3Mask 4 +#define rfbButton4Mask 8 +#define rfbButton5Mask 16 + +#define sz_rfbPointerEventMsg 6 + + + +/*----------------------------------------------------------------------------- + * ClientCutText - the client has new text in its cut buffer. + */ + +typedef struct _rfbClientCutTextMsg { + CARD8 type; /* always rfbClientCutText */ + CARD8 pad1; + CARD16 pad2; + CARD32 length; + /* followed by char text[length] */ +} rfbClientCutTextMsg; + +#define sz_rfbClientCutTextMsg 8 + +/*----------------------------------------------------------------------------- + * FileListRequest + */ + +typedef struct _rfbFileListRequestMsg { + CARD8 type; + CARD8 flags; + CARD16 dirNameSize; + /* Followed by char Dirname[dirNameSize] */ +} rfbFileListRequestMsg; + +#define sz_rfbFileListRequestMsg 4 + +/*----------------------------------------------------------------------------- + * FileDownloadRequest + */ + +typedef struct _rfbFileDownloadRequestMsg { + CARD8 type; + CARD8 compressedLevel; + CARD16 fNameSize; + CARD32 position; + /* Followed by char Filename[fNameSize] */ +} rfbFileDownloadRequestMsg; + +#define sz_rfbFileDownloadRequestMsg 8 + +/*----------------------------------------------------------------------------- + * FileUploadRequest + */ + +typedef struct _rfbFileUploadRequestMsg { + CARD8 type; + CARD8 compressedLevel; + CARD16 fNameSize; + CARD32 position; + /* Followed by char Filename[fNameSize] */ +} rfbFileUploadRequestMsg; + +#define sz_rfbFileUploadRequestMsg 8 + + +/*----------------------------------------------------------------------------- + * FileUploadData + */ + +typedef struct _rfbFileUploadDataMsg { + CARD8 type; + CARD8 compressedLevel; + CARD16 realSize; + CARD16 compressedSize; + /* Followed by File[compressedSize] */ +} rfbFileUploadDataMsg; + +#define sz_rfbFileUploadDataMsg 8 + +/*----------------------------------------------------------------------------- + * FileDownloadCancel + */ + +typedef struct _rfbFileDownloadCancelMsg { + CARD8 type; + CARD8 unused; + CARD16 reasonLen; + /* Followed by reason[reasonLen] */ +} rfbFileDownloadCancelMsg; + +#define sz_rfbFileDownloadCancelMsg 4 + +/*----------------------------------------------------------------------------- + * FileUploadFailed + */ + +typedef struct _rfbFileUploadFailedMsg { + CARD8 type; + CARD8 unused; + CARD16 reasonLen; + /* Followed by reason[reasonLen] */ +} rfbFileUploadFailedMsg; + +#define sz_rfbFileUploadFailedMsg 4 + +/*----------------------------------------------------------------------------- + * FileCreateDirRequest + */ + +typedef struct _rfbFileCreateDirRequestMsg { + CARD8 type; + CARD8 unused; + CARD16 dNameLen; + CARD32 dModTime; + /* Followed by dName[dNameLen] */ +} rfbFileCreateDirRequestMsg; + +#define sz_rfbFileCreateDirRequestMsg 8 + +/*----------------------------------------------------------------------------- + * ChromiumStop - the client has stopped the GL app. + */ + +typedef struct { + CARD8 type; /* always rfbChromiumStop */ + CARD8 pad1; + CARD16 pad2; + CARD32 port; +} rfbChromiumStopMsg; + +#define sz_rfbChromiumStopMsg 8 + +/*----------------------------------------------------------------------------- + * ChromiumExpose - redraw the window + */ + +typedef struct { + CARD8 type; /* always rfbChromiumExpose */ + CARD8 pad1; + CARD16 pad2; + CARD32 winid; +} rfbChromiumExposeMsg; + +#define sz_rfbChromiumExposeMsg 8 + +/*----------------------------------------------------------------------------- + * Union of all client->server messages. + */ + +typedef union _rfbClientToServerMsg { + CARD8 type; + rfbSetPixelFormatMsg spf; + rfbFixColourMapEntriesMsg fcme; + rfbSetEncodingsMsg se; + rfbFramebufferUpdateRequestMsg fur; + rfbKeyEventMsg ke; + rfbPointerEventMsg pe; + rfbClientCutTextMsg cct; + rfbFileListRequestMsg flr; + rfbFileDownloadRequestMsg fdr; + rfbFileUploadRequestMsg fupr; + rfbFileUploadDataMsg fud; + rfbFileDownloadCancelMsg fdc; + rfbFileUploadFailedMsg fuf; + rfbFileCreateDirRequestMsg fcdr; + rfbChromiumStopMsg csd; + rfbChromiumExposeMsg cse; +} rfbClientToServerMsg; diff -pNur xorg-server-1.4.orig/hw/vnc/rfbserver.c xorg-server-1.4/hw/vnc/rfbserver.c --- xorg-server-1.4.orig/hw/vnc/rfbserver.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rfbserver.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,2308 @@ +/* + * rfbserver.c - deal with server-side of the RFB protocol. + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2000-2004 Constantin Kaplinsky. All Rights Reserved. + * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* Use ``#define CORBA'' to enable CORBA control interface */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <pwd.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include "input.h" +#include "mipointer.h" +#if XFREE86VNC +#include <micmap.h> +#endif +#ifdef CHROMIUM +#include "mivalidate.h" +#endif +#include "rfb.h" +#include "windowstr.h" +#include "sprite.h" +#include "propertyst.h" +#include <X11/Xatom.h> +#include <mi.h> + +#ifdef CORBA +#include <vncserverctrl.h> +#endif + +#ifdef CHROMIUM +struct CRWindowTable *windowTable = NULL; +#endif + +extern Atom VNC_CONNECT; + +rfbClientPtr rfbClientHead = NULL; /* list of all VNC clients/viewers */ +rfbClientPtr pointerClient = NULL; /* Mutex for pointer events */ + +static rfbClientPtr rfbNewClient(ScreenPtr pScreen, int sock); +static void rfbProcessClientProtocolVersion(rfbClientPtr cl); +static void rfbProcessClientInitMessage(rfbClientPtr cl); +static void rfbSendInteractionCaps(rfbClientPtr cl); +static void rfbProcessClientNormalMessage(rfbClientPtr cl); +static Bool rfbSendCopyRegion(rfbClientPtr cl, RegionPtr reg, int dx, int dy); +static Bool rfbSendLastRectMarker(rfbClientPtr cl); + +static char *text = NULL; + +void +rfbRootPropertyChange(ScreenPtr pScreen) +{ + PropertyPtr pProp; + WindowPtr pWin = WindowTable[pScreen->myNum]; + + pProp = wUserProps (pWin); + + while (pProp) { + if ((pProp->propertyName == XA_CUT_BUFFER0) && + (pProp->type == XA_STRING) && + (pProp->format == 8)) + { + /* Ensure we don't keep re-sending cut buffer */ + + if ( (text && pProp->data && strncmp(text, pProp->data, pProp->size)) || !text) + rfbGotXCutText(pProp->data, pProp->size); + + if (text) xfree(text); + text = xalloc(1 + pProp->size); + if (! text) return; + if (pProp->data) memcpy(text, pProp->data, pProp->size); + text[pProp->size] = '\0'; + + return; + } + if ((pProp->propertyName == VNC_CONNECT) && (pProp->type == XA_STRING) + && (pProp->format == 8) && (pProp->size > 0)) + { + int i; + rfbClientPtr cl; + int port = 5500; + char *host = (char *)Xalloc(pProp->size+1); + memcpy(host, pProp->data, pProp->size); + host[pProp->size] = 0; + for (i = 0; i < pProp->size; i++) { + if (host[i] == ':') { + port = atoi(&host[i+1]); + host[i] = 0; + } + } + + cl = rfbReverseConnection(pScreen, host, port); + +#ifdef CORBA + if (cl != NULL) + newConnection(cl, (KEYBOARD_DEVICE|POINTER_DEVICE), 1, 1, 1); +#endif + + ChangeWindowProperty(pWin, + pProp->propertyName, pProp->type, + pProp->format, PropModeReplace, + 0, NULL, + FALSE + ); + + free(host); + } + pProp = pProp->next; + } +} + +int +rfbBitsPerPixel(depth) + int depth; +{ + if (depth == 1) return 1; + else if (depth <= 8) return 8; + else if (depth <= 16) return 16; + else return 32; +} + +void +rfbUserAllow(int sock, int accept) +{ + rfbClientPtr cl; + + for (cl = rfbClientHead; cl; cl = cl->next) { + if (cl->sock == sock) { + cl->userAccepted = accept; + } + } +} + +/* + * rfbNewClientConnection is called from sockets.c when a new connection + * comes in. + */ + +void +rfbNewClientConnection(ScreenPtr pScreen, int sock) +{ + rfbClientPtr cl; + + cl = rfbNewClient(pScreen, sock); + + GenerateVncConnectedEvent(sock); + +#if XFREE86VNC + /* Someone is connected - disable VT switching */ + xf86EnableVTSwitch(FALSE); +#endif + +#ifdef CORBA + if (cl != NULL) + newConnection(cl, (KEYBOARD_DEVICE|POINTER_DEVICE), 1, 1, 1); +#endif +} + + +/* + * rfbReverseConnection is called by the CORBA stuff to make an outward + * connection to a "listening" RFB client. + */ + +rfbClientPtr +rfbReverseConnection(ScreenPtr pScreen, char *host, int port) +{ + int sock; + rfbClientPtr cl; + + if ((sock = rfbConnect(pScreen, host, port)) < 0) + return (rfbClientPtr)NULL; + + cl = rfbNewClient(pScreen, sock); + + if (cl) { + cl->reverseConnection = TRUE; + } + + return cl; +} + + +#ifdef CHROMIUM +/* + * rfbSetClip -- + * Generate expose event. + * This function is overkill and should be cleaned up, but it + * works for now. + */ + +void +rfbSetClip (WindowPtr pWin, BOOL enable) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + WindowPtr pChild; + Bool WasViewable = (Bool)(pWin->viewable); + Bool anyMarked = FALSE; + RegionPtr pOldClip = NULL, bsExposed; +#ifdef DO_SAVE_UNDERS + Bool dosave = FALSE; +#endif + WindowPtr pLayerWin; + BoxRec box; + + if (WasViewable) + { + for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) + { + (void) (*pScreen->MarkOverlappedWindows)(pChild, + pChild, + &pLayerWin); + } + (*pScreen->MarkWindow) (pWin); + anyMarked = TRUE; + if (pWin->valdata) + { + if (HasBorder (pWin)) + { + RegionPtr borderVisible; + + borderVisible = REGION_CREATE(pScreen, NullBox, 1); + REGION_SUBTRACT(pScreen, borderVisible, + &pWin->borderClip, &pWin->winSize); + pWin->valdata->before.borderVisible = borderVisible; + } + pWin->valdata->before.resized = TRUE; + } + } + + /* + * Use REGION_BREAK to avoid optimizations in ValidateTree + * that assume the root borderClip can't change well, normally + * it doesn't...) + */ + if (enable) + { + box.x1 = 0; + box.y1 = 0; + box.x2 = pScreen->width; + box.y2 = pScreen->height; + REGION_INIT (pScreen, &pWin->winSize, &box, 1); + REGION_INIT (pScreen, &pWin->borderSize, &box, 1); + if (WasViewable) + REGION_RESET(pScreen, &pWin->borderClip, &box); + pWin->drawable.width = pScreen->width; + pWin->drawable.height = pScreen->height; + REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList); + } + else + { + REGION_EMPTY(pScreen, &pWin->borderClip); + REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList); + } + + ResizeChildrenWinSize (pWin, 0, 0, 0, 0); + + if (WasViewable) + { + if (pWin->backStorage) + { + pOldClip = REGION_CREATE(pScreen, NullBox, 1); + REGION_COPY(pScreen, pOldClip, &pWin->clipList); + } + + if (pWin->firstChild) + { + anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin->firstChild, + pWin->firstChild, + (WindowPtr *)NULL); + } + else + { + (*pScreen->MarkWindow) (pWin); + anyMarked = TRUE; + } + +#ifdef DO_SAVE_UNDERS + if (DO_SAVE_UNDERS(pWin)) + { + dosave = (*pScreen->ChangeSaveUnder)(pLayerWin, pLayerWin); + } +#endif /* DO_SAVE_UNDERS */ + + if (anyMarked) + (*pScreen->ValidateTree)(pWin, NullWindow, VTOther); + } + + if (pWin->backStorage && + ((pWin->backingStore == Always) || WasViewable)) + { + if (!WasViewable) + pOldClip = &pWin->clipList; /* a convenient empty region */ + bsExposed = (*pScreen->TranslateBackingStore) + (pWin, 0, 0, pOldClip, + pWin->drawable.x, pWin->drawable.y); + if (WasViewable) + REGION_DESTROY(pScreen, pOldClip); + if (bsExposed) + { + RegionPtr valExposed = NullRegion; + + if (pWin->valdata) + valExposed = &pWin->valdata->after.exposed; + (*pScreen->WindowExposures) (pWin, valExposed, bsExposed); + if (valExposed) + REGION_EMPTY(pScreen, valExposed); + REGION_DESTROY(pScreen, bsExposed); + } + } + if (WasViewable) + { + if (anyMarked) + (*pScreen->HandleExposures)(pWin); +#ifdef DO_SAVE_UNDERS + if (dosave) + (*pScreen->PostChangeSaveUnder)(pLayerWin, pLayerWin); +#endif /* DO_SAVE_UNDERS */ + if (anyMarked && pScreen->PostValidateTree) + (*pScreen->PostValidateTree)(pWin, NullWindow, VTOther); + } + if (pWin->realized) + WindowsRestructured (); + FlushAllOutput (); +} +#endif /* CHROMIUM */ + +/* + * rfbNewClient is called when a new connection has been made by whatever + * means. + */ + +static rfbClientPtr +rfbNewClient(ScreenPtr pScreen, int sock) +{ + rfbProtocolVersionMsg pv; + rfbClientPtr cl; + BoxRec box; + struct sockaddr_in addr; + SOCKLEN_T addrlen = sizeof(struct sockaddr_in); + VNCSCREENPTR(pScreen); + int i; + + if (rfbClientHead == NULL) { + /* no other clients - make sure we don't think any keys are pressed */ + KbdReleaseAllKeys(); + } else { + rfbLog(" (other clients"); + for (cl = rfbClientHead; cl; cl = cl->next) { + rfbLog(" %s",cl->host); + } + rfbLog(")\n"); + } + + cl = (rfbClientPtr)xalloc(sizeof(rfbClientRec)); + +#ifdef CHROMIUM + cl->chromium_port = 0; /* no GL application on this port, yet */ +#endif + cl->userAccepted = 0; /* user hasn't even approached this yet .... */ + cl->sock = sock; + getpeername(sock, (struct sockaddr *)&addr, &addrlen); + cl->host = strdup(inet_ntoa(addr.sin_addr)); + cl->login = NULL; + + /* Dispatch client input to rfbProcessClientProtocolVersion(). */ + cl->state = RFB_PROTOCOL_VERSION; + + cl->viewOnly = FALSE; + cl->reverseConnection = FALSE; + cl->readyForSetColourMapEntries = FALSE; + cl->useCopyRect = FALSE; + cl->preferredEncoding = rfbEncodingRaw; + cl->correMaxWidth = 48; + cl->correMaxHeight = 48; + cl->pScreen = pScreen; + + REGION_NULL(pScreen,&cl->copyRegion); + cl->copyDX = 0; + cl->copyDY = 0; + + box.x1 = box.y1 = 0; + box.x2 = pVNC->width; + box.y2 = pVNC->height; + REGION_INIT(pScreen,&cl->modifiedRegion,&box,0); + + REGION_NULL(pScreen,&cl->requestedRegion); + + cl->deferredUpdateScheduled = FALSE; + cl->deferredUpdateTimer = NULL; + + cl->format = pVNC->rfbServerFormat; + cl->translateFn = rfbTranslateNone; + cl->translateLookupTable = NULL; + + cl->tightCompressLevel = TIGHT_DEFAULT_COMPRESSION; + cl->tightQualityLevel = -1; + for (i = 0; i < 4; i++) + cl->zsActive[i] = FALSE; + + cl->enableCursorShapeUpdates = FALSE; + cl->enableCursorPosUpdates = FALSE; + cl->enableLastRectEncoding = FALSE; +#ifdef CHROMIUM + cl->enableChromiumEncoding = FALSE; +#endif + + cl->next = rfbClientHead; + rfbClientHead = cl; + + rfbResetStats(cl); + + cl->compStreamInited = FALSE; + cl->compStream.total_in = 0; + cl->compStream.total_out = 0; + cl->compStream.zalloc = Z_NULL; + cl->compStream.zfree = Z_NULL; + cl->compStream.opaque = Z_NULL; + + cl->zlibCompressLevel = 5; + + sprintf(pv,rfbProtocolVersionFormat,rfbProtocolMajorVersion, + rfbProtocolMinorVersion); + + if (WriteExact(sock, pv, sz_rfbProtocolVersionMsg) < 0) { + rfbLogPerror("rfbNewClient: write"); + rfbCloseSock(pScreen, sock); + return NULL; + } + + return cl; +} + + +/* + * rfbClientConnectionGone is called from sockets.c just after a connection + * has gone away. + */ + +void +rfbClientConnectionGone(sock) + int sock; +{ + rfbClientPtr cl, prev; + int i; +#if XFREE86VNC + int allowvt = TRUE; +#endif + + for (prev = NULL, cl = rfbClientHead; cl; prev = cl, cl = cl->next) { + if (sock == cl->sock) + break; + } + + if (!cl) { + rfbLog("rfbClientConnectionGone: unknown socket %d\n",sock); + return; + } + + rfbLog("rfbClientConnectionGone\n"); + + if (cl->login != NULL) { + rfbLog("VNC Client %s (%s) gone\n", cl->login, cl->host); + free(cl->login); + } else { + rfbLog("VNC Client %s gone\n", cl->host); + } + free(cl->host); + + /* Release the compression state structures if any. */ + if ( cl->compStreamInited == TRUE ) { + deflateEnd( &(cl->compStream) ); + } + + for (i = 0; i < 4; i++) { + if (cl->zsActive[i]) + deflateEnd(&cl->zsStruct[i]); + } + + if (pointerClient == cl) + pointerClient = NULL; + +#ifdef CORBA + destroyConnection(cl); +#endif + + if (prev) + prev->next = cl->next; + else + rfbClientHead = cl->next; + + REGION_UNINIT(cl->pScreen,&cl->copyRegion); + REGION_UNINIT(cl->pScreen,&cl->modifiedRegion); + TimerFree(cl->deferredUpdateTimer); + + rfbPrintStats(cl); + + if (cl->translateLookupTable) free(cl->translateLookupTable); + + xfree(cl); + + GenerateVncDisconnectedEvent(sock); + +#if XFREE86VNC + for (cl = rfbClientHead; cl; cl = cl->next) { + /* still someone connected */ + allowvt = FALSE; + } + + xf86EnableVTSwitch(allowvt); +#endif +} + + +/* + * rfbProcessClientMessage is called when there is data to read from a client. + */ + +void +rfbProcessClientMessage(ScreenPtr pScreen, int sock) +{ + rfbClientPtr cl; + + for (cl = rfbClientHead; cl; cl = cl->next) { + if (sock == cl->sock) + break; + } + + if (!cl) { + rfbLog("rfbProcessClientMessage: unknown socket %d\n",sock); + rfbCloseSock(pScreen, sock); + return; + } + +#ifdef CORBA + if (isClosePending(cl)) { + rfbLog("Closing connection to client %s\n", cl->host); + rfbCloseSock(pScreen, sock); + return; + } +#endif + + switch (cl->state) { + case RFB_PROTOCOL_VERSION: + rfbProcessClientProtocolVersion(cl); + break; + case RFB_SECURITY_TYPE: /* protocol 3.7 */ + rfbProcessClientSecurityType(cl); + break; + case RFB_TUNNELING_TYPE: /* protocol 3.7t */ + rfbProcessClientTunnelingType(cl); + break; + case RFB_AUTH_TYPE: /* protocol 3.7t */ + rfbProcessClientAuthType(cl); + break; + case RFB_AUTHENTICATION: + rfbVncAuthProcessResponse(cl); + break; + case RFB_INITIALISATION: + rfbProcessClientInitMessage(cl); + break; + default: + rfbProcessClientNormalMessage(cl); + } +} + + +/* + * rfbProcessClientProtocolVersion is called when the client sends its + * protocol version. + */ + +static void +rfbProcessClientProtocolVersion(cl) + rfbClientPtr cl; +{ + rfbProtocolVersionMsg pv; + int n, major, minor; + + if ((n = ReadExact(cl->sock, pv, sz_rfbProtocolVersionMsg)) <= 0) { + if (n == 0) + rfbLog("rfbProcessClientProtocolVersion: client gone\n"); + else + rfbLogPerror("rfbProcessClientProtocolVersion: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + pv[sz_rfbProtocolVersionMsg] = 0; + if (sscanf(pv,rfbProtocolVersionFormat,&major,&minor) != 2) { + rfbLog("rfbProcessClientProtocolVersion: not a valid RFB client\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + rfbLog("Using protocol version %d.%d\n", major, minor); + + if (major != rfbProtocolMajorVersion) { + rfbLog("RFB protocol version mismatch - server %d.%d, client %d.%d\n", + rfbProtocolMajorVersion,rfbProtocolMinorVersion,major,minor); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* Always use one of the two standard versions of the RFB protocol. */ + cl->protocol_minor_ver = minor; + if (minor > rfbProtocolMinorVersion) { + cl->protocol_minor_ver = rfbProtocolMinorVersion; + } else if (minor < rfbProtocolMinorVersion) { + cl->protocol_minor_ver = rfbProtocolFallbackMinorVersion; + } + if (minor != rfbProtocolMinorVersion && + minor != rfbProtocolFallbackMinorVersion) { + rfbLog("Non-standard protocol version %d.%d, using %d.%d instead\n", + major, minor, rfbProtocolMajorVersion, cl->protocol_minor_ver); + } + + /* TightVNC protocol extensions are not enabled yet. */ + cl->protocol_tightvnc = FALSE; + + rfbAuthNewClient(cl); +} + +/* + * rfbClientConnFailed is called when a client connection has failed + * before the authentication stage. + */ + +void +rfbClientConnFailed(cl, reason) + rfbClientPtr cl; + char *reason; +{ + int headerLen, reasonLen; + char buf[8]; + + headerLen = (cl->protocol_minor_ver >= 7) ? 1 : 4; + reasonLen = strlen(reason); + ((CARD32 *)buf)[0] = 0; + ((CARD32 *)buf)[1] = Swap32IfLE(reasonLen); + + if ( WriteExact(cl->sock, buf, headerLen) < 0 || + WriteExact(cl->sock, buf + 4, 4) < 0 || + WriteExact(cl->sock, reason, reasonLen) < 0 ) { + rfbLogPerror("rfbClientConnFailed: write"); + } + + rfbCloseSock(cl->pScreen, cl->sock); +} + + +/* + * rfbProcessClientInitMessage is called when the client sends its + * initialisation message. + */ + +static void +rfbProcessClientInitMessage(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + rfbClientInitMsg ci; + char buf[256]; + rfbServerInitMsg *si = (rfbServerInitMsg *)buf; + struct passwd *user; + int len, n; + rfbClientPtr otherCl, nextCl; + + if ((n = ReadExact(cl->sock, (char *)&ci,sz_rfbClientInitMsg)) <= 0) { + if (n == 0) + rfbLog("rfbProcessClientInitMessage: client gone\n"); + else + rfbLogPerror("rfbProcessClientInitMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + si->framebufferWidth = Swap16IfLE(pVNC->width); + si->framebufferHeight = Swap16IfLE(pVNC->height); + si->format = pVNC->rfbServerFormat; + si->format.redMax = Swap16IfLE(si->format.redMax); + si->format.greenMax = Swap16IfLE(si->format.greenMax); + si->format.blueMax = Swap16IfLE(si->format.blueMax); + + user = getpwuid(getuid()); + + if (strlen(desktopName) > 128) /* sanity check on desktop name len */ + desktopName[128] = 0; + + if (user) { + sprintf(buf + sz_rfbServerInitMsg, "%s's %s desktop (%s:%s)", + user->pw_name, desktopName, rfbThisHost, display); + } else { + sprintf(buf + sz_rfbServerInitMsg, "%s desktop (%s:%s)", + desktopName, rfbThisHost, display); + } + len = strlen(buf + sz_rfbServerInitMsg); + si->nameLength = Swap32IfLE(len); + + if (WriteExact(cl->sock, buf, sz_rfbServerInitMsg + len) < 0) { + rfbLogPerror("rfbProcessClientInitMessage: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + if (cl->protocol_tightvnc) + rfbSendInteractionCaps(cl); /* protocol 3.7t */ + + /* Dispatch client input to rfbProcessClientNormalMessage(). */ + cl->state = RFB_NORMAL; + + if (!cl->reverseConnection && + (pVNC->rfbNeverShared || (!pVNC->rfbAlwaysShared && !ci.shared))) { + + if (pVNC->rfbDontDisconnect) { + for (otherCl = rfbClientHead; otherCl; otherCl = otherCl->next) { + if ((otherCl != cl) && (otherCl->state == RFB_NORMAL)) { + rfbLog("-dontdisconnect: Not shared & existing client\n"); + rfbLog(" refusing new client %s\n", cl->host); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + } + } else { + for (otherCl = rfbClientHead; otherCl; otherCl = nextCl) { + nextCl = otherCl->next; + if ((otherCl != cl) && (otherCl->state == RFB_NORMAL)) { + rfbLog("Not shared - closing connection to client %s\n", + otherCl->host); + rfbCloseSock(otherCl->pScreen, otherCl->sock); + } + } + } + } +} + + +/* + * rfbSendInteractionCaps is called after sending the server + * initialisation message, only if the protocol version is 3.130. + * In this function, we send the lists of supported protocol messages + * and encodings. + */ + +/* Update these constants on changing capability lists below! */ +#define N_SMSG_CAPS 0 +#define N_CMSG_CAPS 0 +#define N_ENC_CAPS 12 + +void +rfbSendInteractionCaps(cl) + rfbClientPtr cl; +{ + rfbInteractionCapsMsg intr_caps; + rfbCapabilityInfo enc_list[N_ENC_CAPS]; + int i; + + /* Fill in the header structure sent prior to capability lists. */ + intr_caps.nServerMessageTypes = Swap16IfLE(N_SMSG_CAPS); + intr_caps.nClientMessageTypes = Swap16IfLE(N_CMSG_CAPS); + intr_caps.nEncodingTypes = Swap16IfLE(N_ENC_CAPS); + intr_caps.pad = 0; + + /* Supported server->client message types. */ + /* For future file transfer support: + i = 0; + SetCapInfo(&smsg_list[i++], rfbFileListData, rfbTightVncVendor); + SetCapInfo(&smsg_list[i++], rfbFileDownloadData, rfbTightVncVendor); + SetCapInfo(&smsg_list[i++], rfbFileUploadCancel, rfbTightVncVendor); + SetCapInfo(&smsg_list[i++], rfbFileDownloadFailed, rfbTightVncVendor); + if (i != N_SMSG_CAPS) { + rfbLog("rfbSendInteractionCaps: assertion failed, i != N_SMSG_CAPS\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + */ + + /* Supported client->server message types. */ + /* For future file transfer support: + i = 0; + SetCapInfo(&cmsg_list[i++], rfbFileListRequest, rfbTightVncVendor); + SetCapInfo(&cmsg_list[i++], rfbFileDownloadRequest, rfbTightVncVendor); + SetCapInfo(&cmsg_list[i++], rfbFileUploadRequest, rfbTightVncVendor); + SetCapInfo(&cmsg_list[i++], rfbFileUploadData, rfbTightVncVendor); + SetCapInfo(&cmsg_list[i++], rfbFileDownloadCancel, rfbTightVncVendor); + SetCapInfo(&cmsg_list[i++], rfbFileUploadFailed, rfbTightVncVendor); + if (i != N_CMSG_CAPS) { + rfbLog("rfbSendInteractionCaps: assertion failed, i != N_CMSG_CAPS\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + */ + + /* Encoding types. */ + i = 0; + SetCapInfo(&enc_list[i++], rfbEncodingCopyRect, rfbStandardVendor); + SetCapInfo(&enc_list[i++], rfbEncodingRRE, rfbStandardVendor); + SetCapInfo(&enc_list[i++], rfbEncodingCoRRE, rfbStandardVendor); + SetCapInfo(&enc_list[i++], rfbEncodingHextile, rfbStandardVendor); + SetCapInfo(&enc_list[i++], rfbEncodingZlib, rfbTridiaVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingTight, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingCompressLevel0, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingQualityLevel0, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingXCursor, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingRichCursor, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingPointerPos, rfbTightVncVendor); + SetCapInfo(&enc_list[i++], rfbEncodingLastRect, rfbTightVncVendor); + if (i != N_ENC_CAPS) { + rfbLog("rfbSendInteractionCaps: assertion failed, i != N_ENC_CAPS\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* Send header and capability lists */ + if (WriteExact(cl->sock, (char *)&intr_caps, + sz_rfbInteractionCapsMsg) < 0 || + WriteExact(cl->sock, (char *)&enc_list[0], + sz_rfbCapabilityInfo * N_ENC_CAPS) < 0) { + rfbLogPerror("rfbSendInteractionCaps: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* Dispatch client input to rfbProcessClientNormalMessage(). */ + cl->state = RFB_NORMAL; +} + + +/* + * rfbProcessClientNormalMessage is called when the client has sent a normal + * protocol message. + */ + +static void +rfbProcessClientNormalMessage(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + int n; + rfbClientToServerMsg msg; + char *str; + + if (pVNC->rfbUserAccept) { + /* + * We've asked for another level of user authentication + * If the user has not validated this connected, don't + * process it. + */ + /* + * NOTE: we do it here, so the vncviewer knows it's + * connected, but waiting for the first screen update + */ + if (cl->userAccepted == VNC_USER_UNDEFINED) { + usleep(10); + return; + } + if (cl->userAccepted == VNC_USER_DISCONNECT) { + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + } + + if ((n = ReadExact(cl->sock, (char *)&msg, 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + switch (msg.type) { + + case rfbSetPixelFormat: + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbSetPixelFormatMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + cl->format.bitsPerPixel = msg.spf.format.bitsPerPixel; + cl->format.depth = msg.spf.format.depth; + cl->format.bigEndian = (msg.spf.format.bigEndian ? 1 : 0); + cl->format.trueColour = (msg.spf.format.trueColour ? 1 : 0); + cl->format.redMax = Swap16IfLE(msg.spf.format.redMax); + cl->format.greenMax = Swap16IfLE(msg.spf.format.greenMax); + cl->format.blueMax = Swap16IfLE(msg.spf.format.blueMax); + cl->format.redShift = msg.spf.format.redShift; + cl->format.greenShift = msg.spf.format.greenShift; + cl->format.blueShift = msg.spf.format.blueShift; + + cl->readyForSetColourMapEntries = TRUE; + + rfbSetTranslateFunction(cl); + return; + + + case rfbFixColourMapEntries: + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbFixColourMapEntriesMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + rfbLog("rfbProcessClientNormalMessage: %s", + "FixColourMapEntries unsupported\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + + + case rfbSetEncodings: + { + int i; + CARD32 enc; + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbSetEncodingsMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + msg.se.nEncodings = Swap16IfLE(msg.se.nEncodings); + + cl->preferredEncoding = -1; + cl->useCopyRect = FALSE; + cl->enableCursorShapeUpdates = FALSE; + cl->enableCursorPosUpdates = FALSE; + cl->enableLastRectEncoding = FALSE; +#ifdef CHROMIUM + cl->enableChromiumEncoding = FALSE; +#endif + cl->tightCompressLevel = TIGHT_DEFAULT_COMPRESSION; + cl->tightQualityLevel = -1; + + for (i = 0; i < msg.se.nEncodings; i++) { + if ((n = ReadExact(cl->sock, (char *)&enc, 4)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + enc = Swap32IfLE(enc); + + switch (enc) { + + case rfbEncodingCopyRect: + cl->useCopyRect = TRUE; + rfbLog("Using copyrect encoding for client %s\n", + cl->host); + break; + case rfbEncodingRaw: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using raw encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingRRE: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using rre encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingCoRRE: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using CoRRE encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingHextile: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using hextile encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingZlib: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using zlib encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingTight: + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = enc; + rfbLog("Using tight encoding for client %s\n", + cl->host); + } + break; + case rfbEncodingXCursor: + rfbLog("Enabling X-style cursor updates for client %s\n", + cl->host); + cl->enableCursorShapeUpdates = TRUE; + cl->useRichCursorEncoding = FALSE; + cl->cursorWasChanged = TRUE; + break; + case rfbEncodingRichCursor: + if (!cl->enableCursorShapeUpdates) { + rfbLog("Enabling full-color cursor updates for client " + "%s\n", cl->host); + cl->enableCursorShapeUpdates = TRUE; + cl->useRichCursorEncoding = TRUE; + cl->cursorWasChanged = TRUE; + } + break; + case rfbEncodingPointerPos: + if (!cl->enableCursorPosUpdates) { + rfbLog("Enabling cursor position updates for client %s\n", + cl->host); + cl->enableCursorPosUpdates = TRUE; + cl->cursorWasMoved = TRUE; + cl->cursorX = -1; + cl->cursorY = -1; + } + break; + case rfbEncodingLastRect: + if (!cl->enableLastRectEncoding) { + rfbLog("Enabling LastRect protocol extension for client " + "%s\n", cl->host); + cl->enableLastRectEncoding = TRUE; + } + break; +#ifdef CHROMIUM + case rfbEncodingChromium: + case rfbEncodingChromium2: + if (!cl->enableChromiumEncoding) { + cl->enableChromiumEncoding = TRUE; + /* This tells OpenGL apps/replicate SPUs that new viewer + * has attached. + */ + GenerateVncChromiumConnectedEvent(cl->sock); + if (enc == rfbEncodingChromium) { + /* Generate exposures for all windows */ + WindowPtr pWin = WindowTable[cl->pScreen->myNum]; + rfbSetClip(pWin, 1); + } + else { + /* don't generate exposures for Chromium2 because + * that confused DMX. + */ + } + } + break; +#endif + default: + if ( enc >= (CARD32)rfbEncodingCompressLevel0 && + enc <= (CARD32)rfbEncodingCompressLevel9 ) { + cl->zlibCompressLevel = enc & 0x0F; + cl->tightCompressLevel = enc & 0x0F; + rfbLog("Using compression level %d for client %s\n", + cl->tightCompressLevel, cl->host); + } else if ( enc >= (CARD32)rfbEncodingQualityLevel0 && + enc <= (CARD32)rfbEncodingQualityLevel9 ) { + cl->tightQualityLevel = enc & 0x0F; + rfbLog("Using image quality level %d for client %s\n", + cl->tightQualityLevel, cl->host); + } else { + rfbLog("rfbProcessClientNormalMessage: ignoring unknown " + "encoding %d\n", (int)enc); + } + } + } + + if (cl->preferredEncoding == -1) { + cl->preferredEncoding = rfbEncodingRaw; + rfbLog("No encoding specified - using raw encoding for client %s\n", + cl->host); + } + + if (cl->enableCursorPosUpdates && !cl->enableCursorShapeUpdates) { + rfbLog("Disabling cursor position updates for client %s\n", + cl->host); + cl->enableCursorPosUpdates = FALSE; + } + +#if XFREE86VNC + /* + * With XFree86 and the hardware cursor's we need to put up the + * cursor again, and if we've detected a cursor shapeless client + * we need to disable hardware cursors. + */ + if (!cl->enableCursorShapeUpdates) + pVNC->SWCursor = (Bool *)TRUE; + else + pVNC->SWCursor = (Bool *)FALSE; + + { + int x, y; + miPointerPosition(&x, &y); /*XXX deprecated*/ + (*pVNC->spriteFuncs->SetCursor)(cl->pScreen, pVNC->pCurs, x, y); + } +#endif + + return; + } + + + case rfbFramebufferUpdateRequest: + { + RegionRec tmpRegion; + BoxRec box; + +#ifdef CORBA + addCapability(cl, DISPLAY_DEVICE); +#endif + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbFramebufferUpdateRequestMsg-1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + box.x1 = Swap16IfLE(msg.fur.x); + box.y1 = Swap16IfLE(msg.fur.y); + box.x2 = box.x1 + Swap16IfLE(msg.fur.w); + box.y2 = box.y1 + Swap16IfLE(msg.fur.h); + SAFE_REGION_INIT(cl->pScreen,&tmpRegion,&box,0); + + REGION_UNION(cl->pScreen, &cl->requestedRegion, &cl->requestedRegion, + &tmpRegion); + + if (!cl->readyForSetColourMapEntries) { + /* client hasn't sent a SetPixelFormat so is using server's */ + cl->readyForSetColourMapEntries = TRUE; + if (!cl->format.trueColour) { + if (!rfbSetClientColourMap(cl, 0, 0)) { + REGION_UNINIT(cl->pScreen,&tmpRegion); + return; + } + } + } + + if (!msg.fur.incremental) { + REGION_UNION(cl->pScreen,&cl->modifiedRegion,&cl->modifiedRegion, + &tmpRegion); + REGION_SUBTRACT(cl->pScreen,&cl->copyRegion,&cl->copyRegion, + &tmpRegion); + } + +#ifndef DMXVNC + /* don't try to send any pixel data - we'll crash */ + if (FB_UPDATE_PENDING(cl)) { + rfbSendFramebufferUpdate(cl->pScreen, cl); + } +#endif + + REGION_UNINIT(cl->pScreen,&tmpRegion); + return; + } + + case rfbKeyEvent: + + cl->rfbKeyEventsRcvd++; + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbKeyEventMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + +#ifdef CORBA + addCapability(cl, KEYBOARD_DEVICE); + + if (!isKeyboardEnabled(cl)) + return; +#endif + /*ErrorF("Key event: %d\n", msg.ke.key);*/ + if (!pVNC->rfbViewOnly && !cl->viewOnly) { + KbdAddEvent(msg.ke.down, (KeySym)Swap32IfLE(msg.ke.key), cl); + } + return; + + + case rfbPointerEvent: + + cl->rfbPointerEventsRcvd++; + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbPointerEventMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + +#ifdef CORBA + addCapability(cl, POINTER_DEVICE); + + if (!isPointerEnabled(cl)) + return; +#endif + + if (pointerClient && (pointerClient != cl)) + return; + + if (msg.pe.buttonMask == 0) + pointerClient = NULL; + else + pointerClient = cl; + + if (!pVNC->rfbViewOnly && !cl->viewOnly) { + cl->cursorX = (int)Swap16IfLE(msg.pe.x); + cl->cursorY = (int)Swap16IfLE(msg.pe.y); + PtrAddEvent(msg.pe.buttonMask, cl->cursorX, cl->cursorY, cl); + } + return; + + + case rfbClientCutText: + + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbClientCutTextMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + msg.cct.length = Swap32IfLE(msg.cct.length); + + str = (char *)xalloc(msg.cct.length); + + if ((n = ReadExact(cl->sock, str, msg.cct.length)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + xfree(str); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* NOTE: We do not accept cut text from a view-only client */ + if (!cl->viewOnly) + rfbSetXCutText(str, msg.cct.length); + + xfree(str); + return; + +#ifdef CHROMIUM + case rfbChromiumStop: + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbChromiumStopMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* would we use msg.csd.port ??? */ + + cl->chromium_port = 0; + + /* tear down window information */ + { + CRWindowTable *wt, *nextWt = NULL; + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + xfree(wt); + } + + windowTable = NULL; + } + + return; + + case rfbChromiumExpose: + if ((n = ReadExact(cl->sock, ((char *)&msg) + 1, + sz_rfbChromiumExposeMsg - 1)) <= 0) { + if (n != 0) + rfbLogPerror("rfbProcessClientNormalMessage: read"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } + + /* find the window and re-expose it */ + { + CRWindowTable *wt, *nextWt = NULL; + + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->CRwinId == msg.cse.winid) { + WindowPtr pWin; + pWin = LookupIDByType(wt->XwinId, RT_WINDOW); + if (pWin) { + miSendExposures(pWin, &pWin->clipList, + pWin->drawable.x, + pWin->drawable.y); + FlushAllOutput(); + } + } + } + } + + return; +#endif + + default: + + rfbLog("rfbProcessClientNormalMessage: unknown message type %d\n", + msg.type); + rfbLog(" ... closing connection\n"); + rfbCloseSock(cl->pScreen, cl->sock); + return; + } +} + + + +/* + * rfbSendFramebufferUpdate - send the currently pending framebuffer update to + * the RFB client. + */ + +Bool +rfbSendFramebufferUpdate(pScreen, cl) + ScreenPtr pScreen; + rfbClientPtr cl; +{ + VNCSCREENPTR(pScreen); + int i; + int nUpdateRegionRects; + rfbFramebufferUpdateMsg *fu = (rfbFramebufferUpdateMsg *)pVNC->updateBuf; + RegionRec updateRegion, updateCopyRegion; + int dx, dy; + Bool sendCursorShape = FALSE; + Bool sendCursorPos = FALSE; + + /* + * If this client understands cursor shape updates, cursor should be + * removed from the framebuffer. Otherwise, make sure it's put up. + */ + +#if !XFREE86VNC + if (cl->enableCursorShapeUpdates) { + if (pVNC->cursorIsDrawn) + rfbSpriteRemoveCursor(pScreen); + if (!pVNC->cursorIsDrawn && cl->cursorWasChanged) + sendCursorShape = TRUE; + } else { + if (!pVNC->cursorIsDrawn) + rfbSpriteRestoreCursor(pScreen); + } +#else + if (cl->enableCursorShapeUpdates) + if (cl->cursorWasChanged) + sendCursorShape = TRUE; +#endif + + /* + * Do we plan to send cursor position update? + */ + + if (cl->enableCursorPosUpdates && cl->cursorWasMoved) + sendCursorPos = TRUE; + + /* + * The modifiedRegion may overlap the destination copyRegion. We remove + * any overlapping bits from the copyRegion (since they'd only be + * overwritten anyway). + */ + + REGION_SUBTRACT(pScreen, &cl->copyRegion, &cl->copyRegion, + &cl->modifiedRegion); + + /* + * The client is interested in the region requestedRegion. The region + * which should be updated now is the intersection of requestedRegion + * and the union of modifiedRegion and copyRegion. If it's empty then + * no update is needed. + */ + + REGION_NULL(pScreen,&updateRegion); + REGION_UNION(pScreen, &updateRegion, &cl->copyRegion, + &cl->modifiedRegion); + REGION_INTERSECT(pScreen, &updateRegion, &cl->requestedRegion, + &updateRegion); + + if ( !REGION_NOTEMPTY(pScreen,&updateRegion) && + !sendCursorShape && !sendCursorPos ) { + REGION_UNINIT(pScreen,&updateRegion); + return TRUE; + } + + /* + * We assume that the client doesn't have any pixel data outside the + * requestedRegion. In other words, both the source and destination of a + * copy must lie within requestedRegion. So the region we can send as a + * copy is the intersection of the copyRegion with both the requestedRegion + * and the requestedRegion translated by the amount of the copy. We set + * updateCopyRegion to this. + */ + + REGION_NULL(pScreen,&updateCopyRegion); + REGION_INTERSECT(pScreen, &updateCopyRegion, &cl->copyRegion, + &cl->requestedRegion); + REGION_TRANSLATE(pScreen, &cl->requestedRegion, cl->copyDX, cl->copyDY); + REGION_INTERSECT(pScreen, &updateCopyRegion, &updateCopyRegion, + &cl->requestedRegion); + dx = cl->copyDX; + dy = cl->copyDY; + + /* + * Next we remove updateCopyRegion from updateRegion so that updateRegion + * is the part of this update which is sent as ordinary pixel data (i.e not + * a copy). + */ + + REGION_SUBTRACT(pScreen, &updateRegion, &updateRegion, &updateCopyRegion); + + /* + * Finally we leave modifiedRegion to be the remainder (if any) of parts of + * the screen which are modified but outside the requestedRegion. We also + * empty both the requestedRegion and the copyRegion - note that we never + * carry over a copyRegion for a future update. + */ + + REGION_UNION(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &cl->copyRegion); + REGION_SUBTRACT(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &updateRegion); + REGION_SUBTRACT(pScreen, &cl->modifiedRegion, &cl->modifiedRegion, + &updateCopyRegion); + + REGION_EMPTY(pScreen, &cl->requestedRegion); + REGION_EMPTY(pScreen, &cl->copyRegion); + cl->copyDX = 0; + cl->copyDY = 0; + + /* + * Now send the update. + */ + + cl->rfbFramebufferUpdateMessagesSent++; + + if (cl->preferredEncoding == rfbEncodingCoRRE) { + nUpdateRegionRects = 0; + + for (i = 0; i < REGION_NUM_RECTS(&updateRegion); i++) { + int x = REGION_RECTS(&updateRegion)[i].x1; + int y = REGION_RECTS(&updateRegion)[i].y1; + int w = REGION_RECTS(&updateRegion)[i].x2 - x; + int h = REGION_RECTS(&updateRegion)[i].y2 - y; + nUpdateRegionRects += (((w-1) / cl->correMaxWidth + 1) + * ((h-1) / cl->correMaxHeight + 1)); + } + } else if (cl->preferredEncoding == rfbEncodingZlib) { + nUpdateRegionRects = 0; + + for (i = 0; i < REGION_NUM_RECTS(&updateRegion); i++) { + int x = REGION_RECTS(&updateRegion)[i].x1; + int y = REGION_RECTS(&updateRegion)[i].y1; + int w = REGION_RECTS(&updateRegion)[i].x2 - x; + int h = REGION_RECTS(&updateRegion)[i].y2 - y; + nUpdateRegionRects += (((h-1) / (ZLIB_MAX_SIZE( w ) / w)) + 1); + } + } else if (cl->preferredEncoding == rfbEncodingTight) { + nUpdateRegionRects = 0; + + for (i = 0; i < REGION_NUM_RECTS(&updateRegion); i++) { + int x = REGION_RECTS(&updateRegion)[i].x1; + int y = REGION_RECTS(&updateRegion)[i].y1; + int w = REGION_RECTS(&updateRegion)[i].x2 - x; + int h = REGION_RECTS(&updateRegion)[i].y2 - y; + int n = rfbNumCodedRectsTight(cl, x, y, w, h); + if (n == 0) { + nUpdateRegionRects = 0xFFFF; + break; + } + nUpdateRegionRects += n; + } + } else { + nUpdateRegionRects = REGION_NUM_RECTS(&updateRegion); + } + + fu->type = rfbFramebufferUpdate; + if (nUpdateRegionRects != 0xFFFF) { + fu->nRects = Swap16IfLE(REGION_NUM_RECTS(&updateCopyRegion) + + nUpdateRegionRects + + !!sendCursorShape + !!sendCursorPos); + } else { + fu->nRects = 0xFFFF; + } + pVNC->ublen = sz_rfbFramebufferUpdateMsg; + + if (sendCursorShape) { + cl->cursorWasChanged = FALSE; + if (!rfbSendCursorShape(cl, pScreen)) + return FALSE; + } + + if (sendCursorPos) { + cl->cursorWasMoved = FALSE; + if (!rfbSendCursorPos(cl, pScreen)) + return FALSE; + } + + if (REGION_NOTEMPTY(pScreen,&updateCopyRegion)) { + if (!rfbSendCopyRegion(cl,&updateCopyRegion,dx,dy)) { + REGION_UNINIT(pScreen,&updateRegion); + REGION_UNINIT(pScreen,&updateCopyRegion); + return FALSE; + } + } + + REGION_UNINIT(pScreen,&updateCopyRegion); + + for (i = 0; i < REGION_NUM_RECTS(&updateRegion); i++) { + int x = REGION_RECTS(&updateRegion)[i].x1; + int y = REGION_RECTS(&updateRegion)[i].y1; + int w = REGION_RECTS(&updateRegion)[i].x2 - x; + int h = REGION_RECTS(&updateRegion)[i].y2 - y; + + cl->rfbRawBytesEquivalent += (sz_rfbFramebufferUpdateRectHeader + + w * (cl->format.bitsPerPixel / 8) * h); + + switch (cl->preferredEncoding) { + case rfbEncodingRaw: + if (!rfbSendRectEncodingRaw(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + case rfbEncodingRRE: + if (!rfbSendRectEncodingRRE(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + case rfbEncodingCoRRE: + if (!rfbSendRectEncodingCoRRE(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + case rfbEncodingHextile: + if (!rfbSendRectEncodingHextile(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + case rfbEncodingZlib: + if (!rfbSendRectEncodingZlib(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + case rfbEncodingTight: + if (!rfbSendRectEncodingTight(cl, x, y, w, h)) { + REGION_UNINIT(pScreen,&updateRegion); + return FALSE; + } + break; + } + } + + REGION_UNINIT(pScreen,&updateRegion); + + if (nUpdateRegionRects == 0xFFFF && !rfbSendLastRectMarker(cl)) + return FALSE; + + if (!rfbSendUpdateBuf(cl)) + return FALSE; + + return TRUE; +} + + + +/* + * Send the copy region as a string of CopyRect encoded rectangles. + * The only slightly tricky thing is that we should send the messages in + * the correct order so that an earlier CopyRect will not corrupt the source + * of a later one. + */ + +static Bool +rfbSendCopyRegion(cl, reg, dx, dy) + rfbClientPtr cl; + RegionPtr reg; + int dx, dy; +{ + VNCSCREENPTR(cl->pScreen); + int nrects, nrectsInBand, x_inc, y_inc, thisRect, firstInNextBand; + int x, y, w, h; + rfbFramebufferUpdateRectHeader rect; + rfbCopyRect cr; + + nrects = REGION_NUM_RECTS(reg); + + if (dx <= 0) { + x_inc = 1; + } else { + x_inc = -1; + } + + if (dy <= 0) { + thisRect = 0; + y_inc = 1; + } else { + thisRect = nrects - 1; + y_inc = -1; + } + + while (nrects > 0) { + + firstInNextBand = thisRect; + nrectsInBand = 0; + + while ((nrects > 0) && + (REGION_RECTS(reg)[firstInNextBand].y1 + == REGION_RECTS(reg)[thisRect].y1)) + { + firstInNextBand += y_inc; + nrects--; + nrectsInBand++; + } + + if (x_inc != y_inc) { + thisRect = firstInNextBand - y_inc; + } + + while (nrectsInBand > 0) { + if ((pVNC->ublen + sz_rfbFramebufferUpdateRectHeader + + sz_rfbCopyRect) > UPDATE_BUF_SIZE) + { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + x = REGION_RECTS(reg)[thisRect].x1; + y = REGION_RECTS(reg)[thisRect].y1; + w = REGION_RECTS(reg)[thisRect].x2 - x; + h = REGION_RECTS(reg)[thisRect].y2 - y; + + rect.r.x = Swap16IfLE(x); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingCopyRect); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cr.srcX = Swap16IfLE(x - dx); + cr.srcY = Swap16IfLE(y - dy); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&cr, sz_rfbCopyRect); + pVNC->ublen += sz_rfbCopyRect; + + cl->rfbRectanglesSent[rfbEncodingCopyRect]++; + cl->rfbBytesSent[rfbEncodingCopyRect] + += sz_rfbFramebufferUpdateRectHeader + sz_rfbCopyRect; + + thisRect += x_inc; + nrectsInBand--; + } + + thisRect = firstInNextBand; + } + + return TRUE; +} + + +/* + * Send a given rectangle in raw encoding (rfbEncodingRaw). + */ + +Bool +rfbSendRectEncodingRaw(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + rfbFramebufferUpdateRectHeader rect; + int nlines; + int bytesPerLine = w * (cl->format.bitsPerPixel / 8); + int newy = y; + + /* Flush the buffer to guarantee correct alignment for translateFn(). */ + if (pVNC->ublen > 0) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + rect.r.x = Swap16IfLE(x); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingRaw); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect,sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbRectanglesSent[rfbEncodingRaw]++; + cl->rfbBytesSent[rfbEncodingRaw] + += sz_rfbFramebufferUpdateRectHeader + bytesPerLine * h; + + nlines = (UPDATE_BUF_SIZE - pVNC->ublen) / bytesPerLine; + + while (TRUE) { + if (nlines > h) + nlines = h; + + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, &pVNC->rfbServerFormat, + &cl->format, &pVNC->updateBuf[pVNC->ublen], + pVNC->paddedWidthInBytes, w, nlines, x, newy); + + pVNC->ublen += nlines * bytesPerLine; + h -= nlines; + newy += nlines; + + if (h == 0) /* rect fitted in buffer, do next one */ + return TRUE; + + /* buffer full - flush partial rect and do another nlines */ + + if (!rfbSendUpdateBuf(cl)) + return FALSE; + + nlines = (UPDATE_BUF_SIZE - pVNC->ublen) / bytesPerLine; + if (nlines == 0) { + rfbLog("rfbSendRectEncodingRaw: send buffer too small for %d " + "bytes per line\n", bytesPerLine); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + } +} + + +/* + * Send an empty rectangle with encoding field set to value of + * rfbEncodingLastRect to notify client that this is the last + * rectangle in framebuffer update ("LastRect" extension of RFB + * protocol). + */ + +static Bool +rfbSendLastRectMarker(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + rfbFramebufferUpdateRectHeader rect; + + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + rect.encoding = Swap32IfLE(rfbEncodingLastRect); + rect.r.x = 0; + rect.r.y = 0; + rect.r.w = 0; + rect.r.h = 0; + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect,sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbLastRectMarkersSent++; + cl->rfbLastRectBytesSent += sz_rfbFramebufferUpdateRectHeader; + + return TRUE; +} + + +/* + * Send the contents of pVNC->updateBuf. Returns 1 if successful, -1 if + * not (errno should be set). + */ + +Bool +rfbSendUpdateBuf(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + + /* + int i; + for (i = 0; i < pVNC->ublen; i++) { + rfbLog("%02x ",((unsigned char *)pVNC->updateBuf)[i]); + } + rfbLog("\n"); + */ + + if (pVNC->ublen > 0 && WriteExact(cl->sock, (char*)pVNC->updateBuf, pVNC->ublen) < 0) { + rfbLogPerror("rfbSendUpdateBuf: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + pVNC->ublen = 0; + return TRUE; +} + + + +/* + * rfbSendSetColourMapEntries sends a SetColourMapEntries message to the + * client, using values from the currently installed colormap. + */ + +Bool +rfbSendSetColourMapEntries(cl, firstColour, nColours) + rfbClientPtr cl; + int firstColour; + int nColours; +{ +#if !XFREE86VNC + VNCSCREENPTR(cl->pScreen); +#endif + char buf[sz_rfbSetColourMapEntriesMsg + 256 * 3 * 2]; + rfbSetColourMapEntriesMsg *scme = (rfbSetColourMapEntriesMsg *)buf; + CARD16 *rgb = (CARD16 *)(&buf[sz_rfbSetColourMapEntriesMsg]); + EntryPtr pent; + EntryPtr redEntry, greenEntry, blueEntry; + unsigned short redPart, greenPart, bluePart; + int i, len; + + scme->type = rfbSetColourMapEntries; + scme->nColours = Swap16IfLE(nColours); + + len = sz_rfbSetColourMapEntriesMsg; + + /* PseudoColor */ +#if XFREE86VNC + if (miInstalledMaps[cl->pScreen->myNum]->class == PseudoColor) { +#else + if (pVNC->rfbInstalledColormap->class == PseudoColor) { +#endif + scme->firstColour = Swap16IfLE(firstColour); +#if XFREE86VNC + pent = (EntryPtr)&miInstalledMaps[cl->pScreen->myNum]->red[firstColour]; +#else + pent = (EntryPtr)&pVNC->rfbInstalledColormap->red[firstColour]; +#endif + for (i = 0; i < nColours; i++) { + if (pent->fShared) { + rgb[i*3] = Swap16IfLE(pent->co.shco.red->color); + rgb[i*3+1] = Swap16IfLE(pent->co.shco.green->color); + rgb[i*3+2] = Swap16IfLE(pent->co.shco.blue->color); + } else { + rgb[i*3] = Swap16IfLE(pent->co.local.red); + rgb[i*3+1] = Swap16IfLE(pent->co.local.green); + rgb[i*3+2] = Swap16IfLE(pent->co.local.blue); + } + pent++; + } + } + + else { + + /* Break the DirectColor pixel into its r/g/b components */ +#if XFREE86VNC + redPart = (firstColour & miInstalledMaps[cl->pScreen->myNum]->pVisual->redMask) + >> miInstalledMaps[cl->pScreen->myNum]->pVisual->offsetRed; + greenPart = (firstColour & miInstalledMaps[cl->pScreen->myNum]->pVisual->greenMask) + >> miInstalledMaps[cl->pScreen->myNum]->pVisual->offsetGreen; + bluePart = (firstColour & miInstalledMaps[cl->pScreen->myNum]->pVisual->blueMask) + >> miInstalledMaps[cl->pScreen->myNum]->pVisual->offsetBlue; +#else + redPart = (firstColour & pVNC->rfbInstalledColormap->pVisual->redMask) + >> pVNC->rfbInstalledColormap->pVisual->offsetRed; + greenPart = (firstColour & pVNC->rfbInstalledColormap->pVisual->greenMask) + >> pVNC->rfbInstalledColormap->pVisual->offsetGreen; + bluePart = (firstColour & pVNC->rfbInstalledColormap->pVisual->blueMask) + >> pVNC->rfbInstalledColormap->pVisual->offsetBlue; +#endif + + /* + * The firstColour field is only 16 bits. To support 24-bit pixels we + * sneak the red component in the 8-bit padding field which we renamed + * to redIndex. Green and blue are in firstColour (MSB, LSB respectively). + */ + scme->redIndex = Swap16IfLE(redPart); + scme->firstColour = Swap16IfLE((greenPart << 8) | bluePart); + +#if XFREE86VNC + redEntry = (EntryPtr)&miInstalledMaps[cl->pScreen->myNum]->red[redPart]; + greenEntry = (EntryPtr)&miInstalledMaps[cl->pScreen->myNum]->green[greenPart]; + blueEntry = (EntryPtr)&miInstalledMaps[cl->pScreen->myNum]->blue[bluePart]; +#else + redEntry = (EntryPtr)&pVNC->rfbInstalledColormap->red[redPart]; + greenEntry = (EntryPtr)&pVNC->rfbInstalledColormap->green[greenPart]; + blueEntry = (EntryPtr)&pVNC->rfbInstalledColormap->blue[bluePart]; +#endif + for (i = 0; i < nColours; i++) { + if (redEntry->fShared) + rgb[i*3] = Swap16IfLE(redEntry->co.shco.red->color); + else + rgb[i*3] = Swap16IfLE(redEntry->co.local.red); + + if (greenEntry->fShared) + rgb[i*3+1] = Swap16IfLE(greenEntry->co.shco.green->color); + else + rgb[i*3+1] = Swap16IfLE(greenEntry->co.local.green); + + if (blueEntry->fShared) + rgb[i*3+2] = Swap16IfLE(blueEntry->co.shco.blue->color); + else + rgb[i*3+2] = Swap16IfLE(blueEntry->co.local.blue); + + redEntry++; + greenEntry++; + blueEntry++; + } + } + + len += nColours * 3 * 2; + + if (WriteExact(cl->sock, buf, len) < 0) { + rfbLogPerror("rfbSendSetColourMapEntries: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + return TRUE; +} + + +/* + * rfbSendBell sends a Bell message to all the clients. + */ + +void +rfbSendBell(void) +{ + rfbClientPtr cl, nextCl; + rfbBellMsg b; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + b.type = rfbBell; + if (WriteExact(cl->sock, (char *)&b, sz_rfbBellMsg) < 0) { + rfbLogPerror("rfbSendBell: write"); + rfbCloseSock(cl->pScreen, cl->sock); + } + } +} + +#ifdef CHROMIUM +#ifdef sun +extern int inet_aton(const char *cp, struct in_addr *inp); +#endif + + +/** + * This sends a ChromiumStart message to all VNC viewers running on the + * host named by ipaddress. + * This is done in response to an OpenGL/Chromium app calling + * XVncChromiumStart(). + */ +void +rfbSendChromiumStart(unsigned int ipaddress, unsigned int crServerPort, + unsigned int mothershipPort) +{ + rfbClientPtr cl, nextCl; + rfbChromiumStartMsg scd; + struct in_addr ip; + unsigned int vncipaddress; + + /*rfbLog("Enter %s\n", __func__);*/ + /* loop over vnc viewers/clients */ + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + /*rfbLog("%s: cl=%p enableCr=%d\n", __func__, + (void*) cl, cl->enableChromiumEncoding); + */ + if (!cl->enableChromiumEncoding) { + /* viewer is not chromium-enhanced */ + continue; + } + inet_aton(cl->host, &ip); + memcpy(&vncipaddress, &ip, sizeof(unsigned int)); + rfbLog("%s: ipaddr=0x%x vncipaddr=0x%x cl->port=%d\n", + __func__, ipaddress, vncipaddress, cl->chromium_port); + if (ipaddress == vncipaddress /**&& !cl->chromium_port**/) { + cl->chromium_port = crServerPort; + cl->chromium_msport = mothershipPort; + scd.type = rfbChromiumStart; + scd.crServerPort = crServerPort; + scd.mothershipPort = mothershipPort; + if (WriteExact(cl->sock, (char *)&scd, + sz_rfbChromiumStartMsg) < 0) { + rfbLogPerror("rfbSendChromiumStart: write"); + rfbCloseSock(cl->pScreen, cl->sock); + } + /* We only start one client at a time, so break now! */ + break; + } + } + /*rfbLog("Leave %s\n", __func__);*/ +} + + +/** + * Begin monitoring the given X windowid. + * When we detect size/position/visibility changes we'll send a + * rfbChromiumMoveResizeWindow, rfbChromiumClipList, or rfbChromiumWindowShow + * message to the VNC viewer, passing the corresponding Chromium window id. + */ +void +rfbChromiumMonitorWindowID(unsigned int cr_windowid, unsigned long xwindowid) +{ + CRWindowTable *newRec, *wt, *nextWt = NULL; + + if (xwindowid && !cr_windowid) { + /* stop monitoring the X window, remove from list */ + CRWindowTable *prev = NULL; + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (wt->XwinId == xwindowid) { + /* remove */ + if (prev) + prev->next = wt->next; + else + windowTable = wt->next; + xfree(wt); + } + else { + prev = wt; + } + } + return; + } + + /* See if we're already monitoring this window */ + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + /* and if so, update it's window ID */ + if (wt->CRwinId == cr_windowid) { + wt->XwinId = xwindowid; + return; + } + } + + /* o.k, new window so create new slot information */ + newRec = (CRWindowTable *)xalloc(sizeof(CRWindowTable)); + if (!newRec) { + rfbLog("Out of memory allocating CRWindowTable.\n"); + return; + } + + newRec->next = NULL; + newRec->CRwinId = cr_windowid; + newRec->XwinId = xwindowid; + newRec->clipRects = NULL; + newRec->numRects = 0; + + if (!windowTable) { + windowTable = newRec; + } + else { + for (wt = windowTable; wt; wt = nextWt) { + nextWt = wt->next; + if (!wt->next) /* found the next slot */ + wt->next = newRec; + } + } +} + + +void +rfbSendChromiumMoveResizeWindow(unsigned int winid, int x, int y, unsigned int w, unsigned int h) +{ + rfbClientPtr cl, nextCl; + rfbChromiumMoveResizeWindowMsg scm; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + if (!cl->enableChromiumEncoding) + continue; + if (cl->chromium_port) { + scm.type = rfbChromiumMoveResizeWindow; + scm.winid = winid; + scm.x = x; + scm.y = y; + scm.w = w; + scm.h = h; + if (WriteExact(cl->sock, (char *)&scm, + sz_rfbChromiumMoveResizeWindowMsg) < 0) { + rfbLogPerror("rfbSendChromiumMoveResizeWindow: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + } + } +} + +void +rfbSendChromiumClipList(unsigned int winid, BoxPtr pClipRects, int numClipRects) +{ + rfbClientPtr cl, nextCl; + rfbChromiumClipListMsg sccl; + int len = sizeof(BoxRec) * numClipRects; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + if (!cl->enableChromiumEncoding) + continue; + if (cl->chromium_port) { + sccl.type = rfbChromiumClipList; + sccl.winid = winid; + sccl.length = Swap32IfLE(len); + if (WriteExact(cl->sock, (char *)&sccl, + sz_rfbChromiumClipListMsg) < 0) { + rfbLogPerror("rfbSendChromiumClipList: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + if (WriteExact(cl->sock, (char *)pClipRects, len) < 0) { + rfbLogPerror("rfbSendChromiumClipList: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + } + } +} + +void +rfbSendChromiumWindowShow(unsigned int winid, unsigned int show) +{ + rfbClientPtr cl, nextCl; + rfbChromiumWindowShowMsg scws; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + if (!cl->enableChromiumEncoding) + continue; + if (cl->chromium_port) { + scws.type = rfbChromiumWindowShow; + scws.winid = winid; + scws.show = show; + if (WriteExact(cl->sock, (char *)&scws, + sz_rfbChromiumWindowShowMsg) < 0) { + rfbLogPerror("rfbSendChromiumWindowShow: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + } + } +} + +void +rfbSendChromiumWindowDestroy(unsigned int winid) +{ + rfbClientPtr cl, nextCl; + rfbChromiumWindowDestroyMsg scwd; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + if (!cl->enableChromiumEncoding) + continue; + if (cl->chromium_port) { + scwd.type = rfbChromiumWindowDestroy; + scwd.winid = winid; + if (WriteExact(cl->sock, (char *)&scwd, + sz_rfbChromiumWindowDestroyMsg) < 0) { + rfbLogPerror("rfbSendChromiumWindowDestroy: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + } + } +} +#endif /* CHROMIUM */ + +/* + * rfbSendServerCutText sends a ServerCutText message to all the clients. + */ + +void +rfbSendServerCutText(char *str, int len) +{ + rfbClientPtr cl, nextCl = NULL; + rfbServerCutTextMsg sct; + + for (cl = rfbClientHead; cl; cl = nextCl) { + if (cl->state != RFB_NORMAL) continue; + nextCl = cl->next; + sct.type = rfbServerCutText; + sct.length = Swap32IfLE(len); + if (WriteExact(cl->sock, (char *)&sct, + sz_rfbServerCutTextMsg) < 0) { + rfbLogPerror("rfbSendServerCutText: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + continue; + } + if (WriteExact(cl->sock, str, len) < 0) { + rfbLogPerror("rfbSendServerCutText: write\n"); + rfbCloseSock(cl->pScreen, cl->sock); + } + } +} + + + + +/***************************************************************************** + * + * UDP can be used for keyboard and pointer events when the underlying + * network is highly reliable. This is really here to support ORL's + * videotile, whose TCP implementation doesn't like sending lots of small + * packets (such as 100s of pen readings per second!). + */ + +void +rfbNewUDPConnection(sock) + int sock; +{ + if (write(sock, &ptrAcceleration, 1) < 0) { + rfbLogPerror("rfbNewUDPConnection: write"); + } +} + +/* + * Because UDP is a message based service, we can't read the first byte and + * then the rest of the packet separately like we do with TCP. We will always + * get a whole packet delivered in one go, so we ask read() for the maximum + * number of bytes we can possibly get. + */ + +void +rfbProcessUDPInput(ScreenPtr pScreen, int sock) +{ + VNCSCREENPTR(pScreen); + int n; + rfbClientToServerMsg msg; + + if ((n = read(sock, (char *)&msg, sizeof(msg))) <= 0) { + if (n < 0) { + rfbLogPerror("rfbProcessUDPInput: read"); + } + rfbDisconnectUDPSock(pScreen); + return; + } + + switch (msg.type) { + + case rfbKeyEvent: + if (n != sz_rfbKeyEventMsg) { + rfbLog("rfbProcessUDPInput: key event incorrect length\n"); + rfbDisconnectUDPSock(pScreen); + return; + } + if (!pVNC->rfbViewOnly) { + KbdAddEvent(msg.ke.down, (KeySym)Swap32IfLE(msg.ke.key), 0); + } + break; + + case rfbPointerEvent: + if (n != sz_rfbPointerEventMsg) { + rfbLog("rfbProcessUDPInput: ptr event incorrect length\n"); + rfbDisconnectUDPSock(pScreen); + return; + } + if (!pVNC->rfbViewOnly) { + PtrAddEvent(msg.pe.buttonMask, + Swap16IfLE(msg.pe.x), Swap16IfLE(msg.pe.y), 0); + } + break; + + default: + rfbLog("rfbProcessUDPInput: unknown message type %d\n", + msg.type); + rfbDisconnectUDPSock(pScreen); + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/rre.c xorg-server-1.4/hw/vnc/rre.c --- xorg-server-1.4.orig/hw/vnc/rre.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/rre.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,324 @@ +/* + * rre.c + * + * Routines to implement Rise-and-Run-length Encoding (RRE). 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); + + +/* + * rfbSendRectEncodingRRE - send a given rectangle using RRE encoding. + */ + +Bool +rfbSendRectEncodingRRE(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[rfbEncodingRRE]++; + cl->rfbBytesSent[rfbEncodingRRE] += (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); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingRRE); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + hdr.nSubrects = Swap32IfLE(nSubrects); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&hdr, sz_rfbRREHeader); + pVNC->ublen += sz_rfbRREHeader; + + for (i = 0; i < rreAfterBufLen;) { + + int bytesToCopy = UPDATE_BUF_SIZE - pVNC->ublen; + + if (i + bytesToCopy > rreAfterBufLen) { + bytesToCopy = rreAfterBufLen - i; + } + + memcpy(&pVNC->updateBuf[pVNC->ublen], &rreAfterBuf[i], bytesToCopy); + + pVNC->ublen += bytesToCopy; + i += bytesToCopy; + + if (pVNC->ublen == UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + } + + return TRUE; +} + + + +/* + * subrectEncode() encodes the given multicoloured rectangle as a background + * colour overwritten by single-coloured rectangles. It returns the number + * of subrectangles in the encoded buffer, or -1 if subrect encoding won't + * fit in the buffer. It puts the encoded rectangles in rreAfterBuf. The + * single-colour rectangle partition is not optimal, but does find the biggest + * horizontal or vertical rectangle top-left anchored to each consecutive + * coordinate position. + * + * The coding scheme is simply [<bgcolour><subrect><subrect>...] where each + * <subrect> is [<colour><x><y><w><h>]. + */ + +#define DEFINE_SUBRECT_ENCODE(bpp) \ +static int \ +subrectEncode##bpp(data,w,h) \ + CARD##bpp *data; \ + int w; \ + int h; \ +{ \ + CARD##bpp cl; \ + rfbRectangle subrect; \ + int x,y; \ + int i,j; \ + int hx=0,hy,vx=0,vy; \ + int hyflag; \ + CARD##bpp *seg; \ + CARD##bpp *line; \ + int hw,hh,vw,vh; \ + int thex,they,thew,theh; \ + int numsubs = 0; \ + int newLen; \ + CARD##bpp bg = (CARD##bpp)getBgColour((char*)data,w*h,bpp); \ + \ + *((CARD##bpp*)rreAfterBuf) = bg; \ + \ + rreAfterBufLen = (bpp/8); \ + \ + for (y=0; y<h; y++) { \ + line = data+(y*w); \ + for (x=0; x<w; x++) { \ + if (line[x] != bg) { \ + cl = line[x]; \ + hy = y-1; \ + hyflag = 1; \ + for (j=y; j<h; j++) { \ + seg = data+(j*w); \ + if (seg[x] != cl) {break;} \ + i = x; \ + while ((seg[i] == cl) && (i < w)) i += 1; \ + i -= 1; \ + if (j == y) vx = hx = i; \ + if (i < vx) vx = i; \ + if ((hyflag > 0) && (i >= hx)) {hy += 1;} else {hyflag = 0;} \ + } \ + vy = j-1; \ + \ + /* We now have two possible subrects: (x,y,hx,hy) and (x,y,vx,vy) \ + * We'll choose the bigger of the two. \ + */ \ + hw = hx-x+1; \ + hh = hy-y+1; \ + vw = vx-x+1; \ + vh = vy-y+1; \ + \ + thex = x; \ + they = y; \ + \ + if ((hw*hh) > (vw*vh)) { \ + thew = hw; \ + theh = hh; \ + } else { \ + thew = vw; \ + theh = vh; \ + } \ + \ + subrect.x = Swap16IfLE(thex); \ + subrect.y = Swap16IfLE(they); \ + subrect.w = Swap16IfLE(thew); \ + subrect.h = Swap16IfLE(theh); \ + \ + newLen = rreAfterBufLen + (bpp/8) + sz_rfbRectangle; \ + if ((newLen > (w * h * (bpp/8))) || (newLen > rreAfterBufSize)) \ + return -1; \ + \ + numsubs += 1; \ + *((CARD##bpp*)(rreAfterBuf + rreAfterBufLen)) = cl; \ + rreAfterBufLen += (bpp/8); \ + memcpy(&rreAfterBuf[rreAfterBufLen],&subrect,sz_rfbRectangle); \ + rreAfterBufLen += sz_rfbRectangle; \ + \ + /* \ + * Now mark the subrect as done. \ + */ \ + for (j=they; j < (they+theh); j++) { \ + for (i=thex; i < (thex+thew); i++) { \ + data[j*w+i] = bg; \ + } \ + } \ + } \ + } \ + } \ + \ + return numsubs; \ +} + +DEFINE_SUBRECT_ENCODE(8) +DEFINE_SUBRECT_ENCODE(16) +DEFINE_SUBRECT_ENCODE(32) + + +/* + * getBgColour() gets the most prevalent colour in a byte array. + */ +static CARD32 +getBgColour(data,size,bpp) + char *data; + int size; + int bpp; +{ + +#define NUMCLRS 256 + + static int counts[NUMCLRS]; + int i,j,k; + + int maxcount = 0; + CARD8 maxclr = 0; + + if (bpp != 8) { + if (bpp == 16) { + return ((CARD16 *)data)[0]; + } else if (bpp == 32) { + return ((CARD32 *)data)[0]; + } else { + rfbLog("getBgColour: bpp %d?\n",bpp); + exit(1); + } + } + + for (i=0; i<NUMCLRS; i++) { + counts[i] = 0; + } + + for (j=0; j<size; j++) { + k = (int)(((CARD8 *)data)[j]); + if (k >= NUMCLRS) { + rfbLog("getBgColour: unusual colour = %d\n", k); + exit(1); + } + counts[k] += 1; + if (counts[k] > maxcount) { + maxcount = counts[k]; + maxclr = ((CARD8 *)data)[j]; + } + } + + return maxclr; +} diff -pNur xorg-server-1.4.orig/hw/vnc/sockets.c xorg-server-1.4/hw/vnc/sockets.c --- xorg-server-1.4.orig/hw/vnc/sockets.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/sockets.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,656 @@ +/* + * sockets.c - deal with TCP & UDP sockets. + * + * This code should be independent of any changes in the RFB protocol. It just + * deals with the X server scheduling stuff, calling rfbNewClientConnection and + * rfbProcessClientMessage to actually deal with the protocol. If a socket + * needs to be closed for any reason then rfbCloseSock should be called, and + * this in turn will call rfbClientConnectionGone. To make an active + * connection out, call rfbConnect - note that this does _not_ call + * rfbNewClientConnection. + * + * This file is divided into two types of function. Those beginning with + * "rfb" are specific to sockets using the RFB protocol. Those without the + * "rfb" prefix are more general socket routines (which are used by the http + * code). + * + * Thanks to Karl Hakimian for pointing out that some platforms return EAGAIN + * not EWOULDBLOCK. + * + * 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 <sys/types.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <fcntl.h> +#include <errno.h> +#include "windowstr.h" + +#ifndef USE_LIBWRAP +#define USE_LIBWRAP 0 +#endif +#if USE_LIBWRAP +#include <syslog.h> +#include <tcpd.h> +int allow_severity = LOG_INFO; +int deny_severity = LOG_WARNING; +#endif + +#include "rfb.h" + +int rfbMaxClientWait = 20000; /* time (ms) after which we decide client has + gone away - needed to stop us hanging */ + +static struct sockaddr_in udpRemoteAddr; + +/* + * rfbInitSockets sets up the TCP and UDP sockets to listen for RFB + * connections. It does nothing if called again. + */ + +Bool +rfbInitSockets(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + + if (inetdSock != -1) { + const int one = 1; + + if (fcntl(inetdSock, F_SETFL, O_NONBLOCK) < 0) { + rfbLogPerror("fcntl"); + return FALSE; + } + + if (setsockopt(inetdSock, IPPROTO_TCP, TCP_NODELAY, + (char *)&one, sizeof(one)) < 0) { + rfbLogPerror("setsockopt"); + return FALSE; + } + + AddEnabledDevice(inetdSock); + FD_ZERO(&pVNC->allFds); + FD_SET(inetdSock, &pVNC->allFds); + pVNC->maxFd = inetdSock; + return TRUE; + } + + if (pVNC->rfbPort == 0) { + pVNC->rfbPort = 5900 + atoi(display) + pScreen->myNum; + } + + if ((pVNC->rfbListenSock = ListenOnTCPPort(pScreen, pVNC->rfbPort)) < 0) { + rfbLogPerror("ListenOnTCPPort"); + pVNC->rfbPort = 0; + return FALSE; + } + + rfbLog("Listening for VNC connections on TCP port %d\n", pVNC->rfbPort); + + AddEnabledDevice(pVNC->rfbListenSock); + + FD_ZERO(&pVNC->allFds); + FD_SET(pVNC->rfbListenSock, &pVNC->allFds); + pVNC->maxFd = pVNC->rfbListenSock; + + if (pVNC->udpPort != 0) { + rfbLog("rfbInitSockets: listening for input on UDP port %d\n",pVNC->udpPort); + + if ((pVNC->udpSock = ListenOnUDPPort(pScreen, pVNC->udpPort)) < 0) { + rfbLogPerror("ListenOnUDPPort"); + return FALSE; + } + AddEnabledDevice(pVNC->udpSock); + FD_SET(pVNC->udpSock, &pVNC->allFds); + pVNC->maxFd = max(pVNC->udpSock,pVNC->maxFd); + } + + return TRUE; +} + + +/* + * rfbCheckFds is called from ProcessInputEvents to check for input on the RFB + * socket(s). If there is input to process, the appropriate function in the + * RFB server code will be called (rfbNewClientConnection, + * rfbProcessClientMessage, etc). + */ + +void +rfbCheckFds(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); +#if XFREE86VNC + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; +#endif + int nfds; + fd_set fds; + struct timeval tv; + struct sockaddr_in addr; + SOCKLEN_T addrlen = sizeof(addr); + char buf[6]; + const int one = 1; + int sock; + static Bool inetdInitDone = FALSE; + + if (!inetdInitDone && inetdSock != -1) { + rfbNewClientConnection(pScreen, inetdSock); + inetdInitDone = TRUE; + } + + memcpy((char *)&fds, (char *)&pVNC->allFds, sizeof(fd_set)); + tv.tv_sec = 0; + tv.tv_usec = 0; + nfds = select(pVNC->maxFd + 1, &fds, NULL, NULL, &tv); + if (nfds == 0) { + return; + } + if (nfds < 0) { + if (errno != EINTR) + rfbLogPerror("rfbCheckFds: select"); + return; + } + + if (pVNC->rfbListenSock != -1 && FD_ISSET(pVNC->rfbListenSock, &fds)) { + + if ((sock = accept(pVNC->rfbListenSock, + (struct sockaddr *)&addr, &addrlen)) < 0) { + rfbLogPerror("rfbCheckFds: accept"); + return; + } + + if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) { + rfbLogPerror("rfbCheckFds: fcntl"); + close(sock); + return; + } + + if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + (char *)&one, sizeof(one)) < 0) { + rfbLogPerror("rfbCheckFds: setsockopt"); + close(sock); + return; + } + + rfbLog("\n"); + +#if USE_LIBWRAP + if (!hosts_ctl("Xvnc", STRING_UNKNOWN, inet_ntoa(addr.sin_addr), + STRING_UNKNOWN)) { + rfbLog("Rejected connection from client %s\n", + inet_ntoa(addr.sin_addr)); + close(sock); + return; + } +#endif + + rfbLog("Got VNC connection from client %s\n", inet_ntoa(addr.sin_addr)); + + AddEnabledDevice(sock); + FD_SET(sock, &pVNC->allFds); + pVNC->maxFd = max(sock,pVNC->maxFd); + + rfbNewClientConnection(pScreen, sock); + + FD_CLR(pVNC->rfbListenSock, &fds); + if (--nfds == 0) + return; + } + + if ((pVNC->udpSock != -1) && FD_ISSET(pVNC->udpSock, &fds)) { + + if (recvfrom(pVNC->udpSock, buf, 1, MSG_PEEK, + (struct sockaddr *)&addr, &addrlen) < 0) { + + rfbLogPerror("rfbCheckFds: UDP: recvfrom"); + rfbDisconnectUDPSock(pScreen); + + } else { + + if (!pVNC->udpSockConnected || + (memcmp(&addr, &udpRemoteAddr, addrlen) != 0)) + { + /* new remote end */ + rfbLog("rfbCheckFds: UDP: got connection\n"); + + memcpy(&udpRemoteAddr, &addr, addrlen); + pVNC->udpSockConnected = TRUE; + + if (connect(pVNC->udpSock, + (struct sockaddr *)&addr, addrlen) < 0) { + rfbLogPerror("rfbCheckFds: UDP: connect"); + rfbDisconnectUDPSock(pScreen); + return; + } + + rfbNewUDPConnection(pVNC->udpSock); + } + + rfbProcessUDPInput(pScreen, pVNC->udpSock); + } + + FD_CLR(pVNC->udpSock, &fds); + if (--nfds == 0) + return; + } + + for (sock = 0; sock <= pVNC->maxFd; sock++) { + if (FD_ISSET(sock, &fds) && FD_ISSET(sock, &pVNC->allFds)) { +#if XFREE86VNC + if (!pScrn->vtSema) + rfbCloseSock(pScreen, sock); + else +#endif + rfbProcessClientMessage(pScreen, sock); + } + } +} + + +void +rfbDisconnectUDPSock(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + pVNC->udpSockConnected = FALSE; +} + + +void +rfbCloseSock(ScreenPtr pScreen, int sock) +{ + VNCSCREENPTR(pScreen); + close(sock); + RemoveEnabledDevice(sock); + FD_CLR(sock, &pVNC->allFds); + rfbClientConnectionGone(sock); + if (sock == inetdSock) + GiveUp(0); +} + +#if 0 +/* + * rfbWaitForClient can be called to wait for the RFB client to send us a + * message. When one is received it is processed by calling + * rfbProcessClientMessage(). + */ + +void +rfbWaitForClient(sock) + int sock; +{ + int n; + fd_set fds; + struct timeval tv; + + FD_ZERO(&fds); + FD_SET(sock, &fds); + tv.tv_sec = rfbMaxClientWait / 1000; + tv.tv_usec = (rfbMaxClientWait % 1000) * 1000; + n = select(sock+1, &fds, NULL, NULL, &tv); + if (n < 0) { + rfbLogPerror("rfbWaitForClient: select"); + exit(1); + } + if (n == 0) { + rfbCloseSock(sock); + return; + } + + rfbProcessClientMessage(sock); +} +#endif + +/* + * rfbConnect is called to make a connection out to a given TCP address. + */ + +int +rfbConnect(ScreenPtr pScreen, char *host, int port) +{ + VNCSCREENPTR(pScreen); + int sock; + int one = 1; + + rfbLog("\n"); + rfbLog("Making connection to client on host %s port %d\n", + host,port); + + if ((sock = ConnectToTcpAddr(host, port)) < 0) { + rfbLogPerror("connection failed"); + return -1; + } + + if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) { + rfbLogPerror("fcntl failed"); + close(sock); + return -1; + } + + if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + (char *)&one, sizeof(one)) < 0) { + rfbLogPerror("setsockopt failed"); + close(sock); + return -1; + } + + AddEnabledDevice(sock); + FD_SET(sock, &pVNC->allFds); + pVNC->maxFd = max(sock,pVNC->maxFd); + + return sock; +} + + + + +/* + * ReadExact reads an exact number of bytes on a TCP socket. Returns 1 if + * those bytes have been read, 0 if the other end has closed, or -1 if an error + * occurred (errno is set to ETIMEDOUT if it timed out). + */ + +int +ReadExact(sock, buf, len) + int sock; + char *buf; + int len; +{ + int n; + fd_set fds; + int tries = 5; + struct timeval tv; + + while (len > 0) { + n = read(sock, buf, len); + + if (n > 0) { + + buf += n; + len -= n; + + } else if (n == 0) { + + return 0; + + } else { + if (errno != EWOULDBLOCK && errno != EAGAIN) { + return n; + } + + do { + FD_ZERO(&fds); + FD_SET(sock, &fds); + tv.tv_sec = rfbMaxClientWait / 1000; + tv.tv_usec = (rfbMaxClientWait % 1000) * 1000; + n = select(sock+1, &fds, NULL, NULL, &tv); + tries--; + + /* We really need to retry if we get EINTR, so spin */ + /* If after 5 attempts we're still broke, abort.... */ + + } while ((n < 0 && errno == EINTR) && tries > 0); + + if (n < 0) { + rfbLogPerror("ReadExact: select"); + return n; + } + if (n == 0) { + errno = ETIMEDOUT; + return -1; + } + } + } + return 1; +} + + + +/* + * WriteExact writes an exact number of bytes on a TCP socket. Returns 1 if + * those bytes have been written, or -1 if an error occurred (errno is set to + * ETIMEDOUT if it timed out). + */ + +int +WriteExact(sock, buf, len) + int sock; + char *buf; + int len; +{ + int n; + fd_set fds; + struct timeval tv; +#if 0 + int totalTimeWaited = 0; +#endif + + while (len > 0) { + n = write(sock, buf, len); + + if (n > 0) { + + buf += n; + len -= n; + + } else if (n == 0) { + + rfbLog("WriteExact: write returned 0?\n"); + return -1; + + } else { + if (errno != EWOULDBLOCK && errno != EAGAIN) { + return n; + } + +#if 0 + /* Retry every 5 seconds until we exceed rfbMaxClientWait. We + need to do this because select doesn't necessarily return + immediately when the other end has gone away */ + + FD_ZERO(&fds); + FD_SET(sock, &fds); + tv.tv_sec = 5; + tv.tv_usec = 0; +#else + /* We're in the WakeupHandler now, so don't wait */ + + FD_ZERO(&fds); + FD_SET(sock, &fds); + tv.tv_sec = 0; + tv.tv_usec = 0; +#endif + n = select(sock+1, NULL, &fds, NULL, &tv); +#if 0 + if (n < 0) { + rfbLogPerror("WriteExact: select"); + return n; + } + if (n == 0) { + totalTimeWaited += 5000; + if (totalTimeWaited >= rfbMaxClientWait) { + errno = ETIMEDOUT; + return -1; + } + } else { + totalTimeWaited = 0; + } +#endif + } + } + return 1; +} + + +int +ListenOnTCPPort(ScreenPtr pScreen, int port) +{ + VNCSCREENPTR(pScreen); + struct sockaddr_in addr; + int sock; + int one = 1; + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = pVNC->interface.s_addr; + + if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { + return -1; + } + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (char *)&one, sizeof(one)) < 0) { + close(sock); + return -1; + } + if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + close(sock); + return -1; + } + if (listen(sock, 5) < 0) { + close(sock); + return -1; + } + + return sock; +} + + +int +ConnectToTcpAddr(host, port) + char *host; + int port; +{ + struct hostent *hp; + int sock, n; + struct sockaddr_in addr; + int tries = 5; + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + + if ((addr.sin_addr.s_addr = inet_addr(host)) == -1) + { + if (!(hp = gethostbyname(host))) { + errno = EINVAL; + return -1; + } + addr.sin_addr.s_addr = *(unsigned long *)hp->h_addr; + } + + if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { + return -1; + } + + do { + sock = socket(AF_INET, SOCK_STREAM, 0); + tries--; + + /* We really need to retry if we get EINTR, so spin */ + /* If after 5 attempts we're still broke, abort.... */ + + } while ((sock < 0 && errno == EINTR) && tries > 0); + + if (sock < 0) { + return -1; + } + + tries = 5; + + do { + n = connect(sock, (struct sockaddr *)&addr, (sizeof(addr))); + tries--; + + /* We really need to retry if we get EINTR, so spin */ + /* If after 5 attempts we're still broke, abort.... */ + + } while ((n < 0 && errno == EINTR) && tries > 0); + + if (n < 0) { + close(sock); + return -1; + } + + return sock; +} + + +int +ListenOnUDPPort(ScreenPtr pScreen, int port) +{ + VNCSCREENPTR(pScreen); + struct sockaddr_in addr; + int sock; + int one = 1; + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = pVNC->interface.s_addr; + + if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { + return -1; + } + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (char *)&one, sizeof(one)) < 0) { + return -1; + } + if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + return -1; + } + + return sock; +} + +#if 0 +/* + * rdpInitSockets sets up the TCP for RDP + * connections. It does nothing if called again. + */ + +Bool +rdpInitSockets(ScreenPtr pScreen) +{ + VNCSCREENPTR(pScreen); + + if ((pVNC->rdpListenSock = ListenOnTCPPort(pScreen, pVNC->rdpPort)) < 0) { + rfbLogPerror("ListenOnTCPPort"); + pVNC->rdpPort = 0; + return FALSE; + } + + rfbLog("Listening for RDP connections on TCP port %d\n", pVNC->rdpPort); + + AddEnabledDevice(pVNC->rdpListenSock); + + return TRUE; +} +#endif diff -pNur xorg-server-1.4.orig/hw/vnc/sprite.c xorg-server-1.4/hw/vnc/sprite.c --- xorg-server-1.4.orig/hw/vnc/sprite.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/sprite.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,2452 @@ +/* + * sprite.c + * + * software sprite routines - based on misprite + * + * 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. + */ + +/* $XConsortium: misprite.c,v 5.47 94/04/17 20:27:53 dpw Exp $ */ + +/* + +Copyright (c) 1989 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" +# include <X11/X.h> +# include <X11/Xproto.h> +# include <X11/fonts/font.h> +# include <X11/fonts/fontstruct.h> +# include "misc.h" +# include "pixmapstr.h" +# include "input.h" +# include "mi.h" +# include "cursorstr.h" +# include "scrnintstr.h" +# include "colormapst.h" +# include "windowstr.h" +# include "gcstruct.h" +# include "mipointer.h" +# include "spritest.h" +# include "dixfontstr.h" +#ifdef RENDER +# include "mipict.h" +#endif + +/* + * screen wrappers + */ + +static int rfbSpriteScreenIndex; +static unsigned long rfbSpriteGeneration = 0; + +static Bool rfbSpriteCloseScreen(int i, ScreenPtr pScreen); +static void rfbSpriteGetImage(DrawablePtr pDrawable, int sx, int sy, + int w, int h, unsigned int format, + unsigned long planemask, char *pdstLine); +static void rfbSpriteGetSpans(DrawablePtr pDrawable, int wMax, + DDXPointPtr ppt, int *pwidth, int nspans, + char *pdstStart); +static void rfbSpriteSourceValidate(DrawablePtr pDrawable, int x, int y, + int width, int height); +static Bool rfbSpriteCreateGC(GCPtr pGC); +static void rfbSpriteBlockHandler(int i, pointer blockData, + pointer pTimeout, + pointer pReadMask); +static void rfbSpriteInstallColormap(ColormapPtr pMap); +static void rfbSpriteStoreColors(ColormapPtr pMap, int ndef, + xColorItem *pdef); + +static void rfbSpritePaintWindowBackground(WindowPtr pWin, + RegionPtr pRegion, int what); +static void rfbSpritePaintWindowBorder(WindowPtr pWin, + RegionPtr pRegion, int what); +static void rfbSpriteCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, + RegionPtr pRegion); +static void rfbSpriteClearToBackground(WindowPtr pWin, int x, int y, + int w, int h, + Bool generateExposures); + +#ifdef RENDER +static void rfbSpriteComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height); + +static void rfbSpriteGlyphs(CARD8 op, + PicturePtr pSrc, + PicturePtr pDst, + PictFormatPtr maskFormat, + INT16 xSrc, + INT16 ySrc, + int nlist, + GlyphListPtr list, + GlyphPtr *glyphs); +#endif + +static void rfbSpriteSaveDoomedAreas(WindowPtr pWin, + RegionPtr pObscured, int dx, + int dy); +static RegionPtr rfbSpriteRestoreAreas(WindowPtr pWin, RegionPtr pRgnExposed); +static void rfbSpriteComputeSaved(ScreenPtr pScreen); + +#define SCREEN_PROLOGUE(pScreen, field)\ + ((pScreen)->field = \ + ((rfbSpriteScreenPtr) (pScreen)->devPrivates[rfbSpriteScreenIndex].ptr)->field) + +#define SCREEN_EPILOGUE(pScreen, field, wrapper)\ + ((pScreen)->field = wrapper) + +/* + * GC func wrappers + */ + +static int rfbSpriteGCIndex; + +static void rfbSpriteValidateGC(GCPtr pGC, unsigned long stateChanges, + DrawablePtr pDrawable); +static void rfbSpriteCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst); +static void rfbSpriteDestroyGC(GCPtr pGC); +static void rfbSpriteChangeGC(GCPtr pGC, unsigned long mask); +static void rfbSpriteChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects); +static void rfbSpriteDestroyClip(GCPtr pGC); +static void rfbSpriteCopyClip(GCPtr pgcDst, GCPtr pgcSrc); + +static GCFuncs rfbSpriteGCFuncs = { + rfbSpriteValidateGC, + rfbSpriteChangeGC, + rfbSpriteCopyGC, + rfbSpriteDestroyGC, + rfbSpriteChangeClip, + rfbSpriteDestroyClip, + rfbSpriteCopyClip, +}; + +#define GC_FUNC_PROLOGUE(pGC) \ + rfbSpriteGCPtr pGCPriv = \ + (rfbSpriteGCPtr) (pGC)->devPrivates[rfbSpriteGCIndex].ptr;\ + (pGC)->funcs = pGCPriv->wrapFuncs; \ + if (pGCPriv->wrapOps) \ + (pGC)->ops = pGCPriv->wrapOps; + +#define GC_FUNC_EPILOGUE(pGC) \ + pGCPriv->wrapFuncs = (pGC)->funcs; \ + (pGC)->funcs = &rfbSpriteGCFuncs; \ + if (pGCPriv->wrapOps) \ + { \ + pGCPriv->wrapOps = (pGC)->ops; \ + (pGC)->ops = &rfbSpriteGCOps; \ + } + +/* + * GC op wrappers + */ + +static void rfbSpriteFillSpans(DrawablePtr pDrawable, GCPtr pGC, + int nInit, DDXPointPtr pptInit, + int *pwidthInit, int fSorted); +static void rfbSpriteSetSpans(DrawablePtr pDrawable, GCPtr pGC, + char *psrc, DDXPointPtr ppt, int *pwidth, + int nspans, int fSorted); +static void rfbSpritePutImage(DrawablePtr pDrawable, GCPtr pGC, + int depth, int x, int y, int w, int h, + int leftPad, int format, char *pBits); +static RegionPtr rfbSpriteCopyArea(DrawablePtr pSrc, DrawablePtr pDst, + GCPtr pGC, int srcx, int srcy, int w, + int h, int dstx, int dsty); +static RegionPtr rfbSpriteCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, + GCPtr pGC, int srcx, int srcy, int w, + int h, int dstx, int dsty, + unsigned long plane); +static void rfbSpritePolyPoint(DrawablePtr pDrawable, GCPtr pGC, + int mode, int npt, xPoint *pptInit); +static void rfbSpritePolylines(DrawablePtr pDrawable, GCPtr pGC, + int mode, int npt, DDXPointPtr pptInit); +static void rfbSpritePolySegment(DrawablePtr pDrawable, GCPtr pGC, + int nseg, xSegment *pSegs); +static void rfbSpritePolyRectangle(DrawablePtr pDrawable, GCPtr pGC, + int nrects, xRectangle *pRects); +static void rfbSpritePolyArc(DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *parcs); +static void rfbSpriteFillPolygon(DrawablePtr pDrawable, GCPtr pGC, + int shape, int mode, int count, + DDXPointPtr pPts); +static void rfbSpritePolyFillRect(DrawablePtr pDrawable, GCPtr pGC, + int nrectFill, xRectangle *prectInit); +static void rfbSpritePolyFillArc(DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *parcs); +static int rfbSpritePolyText8(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, int count, char *chars); +static int rfbSpritePolyText16(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, int count, + unsigned short *chars); +static void rfbSpriteImageText8(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, int count, char *chars); +static void rfbSpriteImageText16(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, int count, + unsigned short *chars); +static void rfbSpriteImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase); +static void rfbSpritePolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase); +static void rfbSpritePushPixels(GCPtr pGC, PixmapPtr pBitMap, + DrawablePtr pDst, int w, int h, + int x, int y); +#ifdef NEED_LINEHELPER +static void rfbSpriteLineHelper(); +#endif + +static GCOps rfbSpriteGCOps = { + rfbSpriteFillSpans, rfbSpriteSetSpans, rfbSpritePutImage, + rfbSpriteCopyArea, rfbSpriteCopyPlane, rfbSpritePolyPoint, + rfbSpritePolylines, rfbSpritePolySegment, rfbSpritePolyRectangle, + rfbSpritePolyArc, rfbSpriteFillPolygon, rfbSpritePolyFillRect, + rfbSpritePolyFillArc, rfbSpritePolyText8, rfbSpritePolyText16, + rfbSpriteImageText8, rfbSpriteImageText16, rfbSpriteImageGlyphBlt, + rfbSpritePolyGlyphBlt, rfbSpritePushPixels +#ifdef NEED_LINEHELPER + , rfbSpriteLineHelper +#endif +}; + +/* + * testing only -- remove cursor for every draw. Eventually, + * each draw operation will perform a bounding box check against + * the saved cursor area + */ + +#define GC_SETUP_CHEAP(pDrawable) \ + rfbSpriteScreenPtr pScreenPriv = (rfbSpriteScreenPtr) \ + (pDrawable)->pScreen->devPrivates[rfbSpriteScreenIndex].ptr; \ + +#define GC_SETUP(pDrawable, pGC) \ + GC_SETUP_CHEAP(pDrawable) \ + rfbSpriteGCPtr pGCPrivate = (rfbSpriteGCPtr) \ + (pGC)->devPrivates[rfbSpriteGCIndex].ptr; \ + GCFuncs *oldFuncs = pGC->funcs; + +#define GC_SETUP_AND_CHECK(pDrawable, pGC) \ + GC_SETUP(pDrawable, pGC); \ + if (GC_CHECK((WindowPtr)pDrawable)) \ + rfbSpriteRemoveCursor (pDrawable->pScreen); + +#define GC_CHECK(pWin) \ + (pVNC->cursorIsDrawn && \ + (pScreenPriv->pCacheWin == pWin ? \ + pScreenPriv->isInCacheWin : ( \ + (pScreenPriv->pCacheWin = (pWin)) , \ + (pScreenPriv->isInCacheWin = \ + (pWin)->drawable.x < pScreenPriv->saved.x2 && \ + pScreenPriv->saved.x1 < (pWin)->drawable.x + \ + (int) (pWin)->drawable.width && \ + (pWin)->drawable.y < pScreenPriv->saved.y2 && \ + pScreenPriv->saved.y1 < (pWin)->drawable.y + \ + (int) (pWin)->drawable.height &&\ + RECT_IN_REGION((pWin)->drawable.pScreen, &(pWin)->borderClip, \ + &pScreenPriv->saved) != rgnOUT)))) + +#define GC_OP_PROLOGUE(pGC) { \ + (pGC)->funcs = pGCPrivate->wrapFuncs; \ + (pGC)->ops = pGCPrivate->wrapOps; \ + } + +#define GC_OP_EPILOGUE(pGC) { \ + pGCPrivate->wrapOps = (pGC)->ops; \ + (pGC)->funcs = oldFuncs; \ + (pGC)->ops = &rfbSpriteGCOps; \ + } + +/* + * pointer-sprite method table + */ + +static Bool rfbSpriteRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor); +static Bool rfbSpriteUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor); +static void rfbSpriteSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y); +static void rfbSpriteMoveCursor (ScreenPtr pScreen, int x, int y); + +miPointerSpriteFuncRec rfbSpritePointerFuncs = { + rfbSpriteRealizeCursor, + rfbSpriteUnrealizeCursor, + rfbSpriteSetCursor, + rfbSpriteMoveCursor, +}; + +/* + * other misc functions + */ + +static Bool rfbDisplayCursor (ScreenPtr pScreen, CursorPtr pCursor); + + +/* + * rfbSpriteInitialize -- called from device-dependent screen + * initialization proc after all of the function pointers have + * been stored in the screen structure. + */ + +Bool +rfbSpriteInitialize (pScreen, cursorFuncs, screenFuncs) + ScreenPtr pScreen; + rfbSpriteCursorFuncPtr cursorFuncs; + miPointerScreenFuncPtr screenFuncs; +{ + rfbSpriteScreenPtr pPriv; + VisualPtr pVisual; +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + + if (rfbSpriteGeneration != serverGeneration) + { + rfbSpriteScreenIndex = AllocateScreenPrivateIndex (); + if (rfbSpriteScreenIndex < 0) + return FALSE; + rfbSpriteGeneration = serverGeneration; + rfbSpriteGCIndex = AllocateGCPrivateIndex (); + } + if (!AllocateGCPrivate(pScreen, rfbSpriteGCIndex, sizeof(rfbSpriteGCRec))) + return FALSE; + pPriv = (rfbSpriteScreenPtr) xalloc (sizeof (rfbSpriteScreenRec)); + if (!pPriv) + return FALSE; + if (!miPointerInitialize (pScreen, &rfbSpritePointerFuncs, screenFuncs,TRUE)) + { + xfree ((pointer) pPriv); + return FALSE; + } + for (pVisual = pScreen->visuals; + pVisual->vid != pScreen->rootVisual; + pVisual++) + ; + pPriv->pVisual = pVisual; + pPriv->CloseScreen = pScreen->CloseScreen; + pPriv->GetImage = pScreen->GetImage; + pPriv->GetSpans = pScreen->GetSpans; + pPriv->SourceValidate = pScreen->SourceValidate; + pPriv->CreateGC = pScreen->CreateGC; +#if 0 + pPriv->BlockHandler = pScreen->BlockHandler; +#endif + pPriv->InstallColormap = pScreen->InstallColormap; + pPriv->StoreColors = pScreen->StoreColors; + pPriv->DisplayCursor = pScreen->DisplayCursor; + + pPriv->PaintWindowBackground = pScreen->PaintWindowBackground; + pPriv->PaintWindowBorder = pScreen->PaintWindowBorder; + pPriv->CopyWindow = pScreen->CopyWindow; + pPriv->ClearToBackground = pScreen->ClearToBackground; + + pPriv->SaveDoomedAreas = pScreen->SaveDoomedAreas; + pPriv->RestoreAreas = pScreen->RestoreAreas; +#ifdef RENDER + if (ps) + { + pPriv->Composite = ps->Composite; + pPriv->Glyphs = ps->Glyphs; + } +#endif + + pPriv->pCursor = NULL; + pPriv->x = 0; + pPriv->y = 0; + pPriv->shouldBeUp = FALSE; + pPriv->pCacheWin = NullWindow; + pPriv->isInCacheWin = FALSE; + pPriv->checkPixels = TRUE; + pPriv->pInstalledMap = NULL; + pPriv->pColormap = NULL; + pPriv->funcs = cursorFuncs; + pPriv->colors[SOURCE_COLOR].red = 0; + pPriv->colors[SOURCE_COLOR].green = 0; + pPriv->colors[SOURCE_COLOR].blue = 0; + pPriv->colors[MASK_COLOR].red = 0; + pPriv->colors[MASK_COLOR].green = 0; + pPriv->colors[MASK_COLOR].blue = 0; + pScreen->devPrivates[rfbSpriteScreenIndex].ptr = (pointer) pPriv; + pScreen->CloseScreen = rfbSpriteCloseScreen; + pScreen->GetImage = rfbSpriteGetImage; + pScreen->GetSpans = rfbSpriteGetSpans; + pScreen->SourceValidate = rfbSpriteSourceValidate; + pScreen->CreateGC = rfbSpriteCreateGC; +#if 0 + pScreen->BlockHandler = rfbSpriteBlockHandler; +#endif + pScreen->InstallColormap = rfbSpriteInstallColormap; + pScreen->StoreColors = rfbSpriteStoreColors; + + pScreen->PaintWindowBackground = rfbSpritePaintWindowBackground; + pScreen->PaintWindowBorder = rfbSpritePaintWindowBorder; + pScreen->CopyWindow = rfbSpriteCopyWindow; + pScreen->ClearToBackground = rfbSpriteClearToBackground; + + pScreen->SaveDoomedAreas = rfbSpriteSaveDoomedAreas; + pScreen->RestoreAreas = rfbSpriteRestoreAreas; + + pScreen->DisplayCursor = rfbDisplayCursor; +#ifdef RENDER + if (ps) + { + ps->Composite = rfbSpriteComposite; + ps->Glyphs = rfbSpriteGlyphs; + } +#endif + + return TRUE; +} + +/* + * Screen wrappers + */ + +/* + * CloseScreen wrapper -- unwrap everything, free the private data + * and call the wrapped function + */ + +static Bool +rfbSpriteCloseScreen (i, pScreen) + ScreenPtr pScreen; +{ + rfbSpriteScreenPtr pScreenPriv; +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + pScreen->CloseScreen = pScreenPriv->CloseScreen; + pScreen->GetImage = pScreenPriv->GetImage; + pScreen->GetSpans = pScreenPriv->GetSpans; + pScreen->SourceValidate = pScreenPriv->SourceValidate; + pScreen->CreateGC = pScreenPriv->CreateGC; +#if 0 + pScreen->BlockHandler = pScreenPriv->BlockHandler; +#endif + pScreen->InstallColormap = pScreenPriv->InstallColormap; + pScreen->StoreColors = pScreenPriv->StoreColors; + + pScreen->PaintWindowBackground = pScreenPriv->PaintWindowBackground; + pScreen->PaintWindowBorder = pScreenPriv->PaintWindowBorder; + pScreen->CopyWindow = pScreenPriv->CopyWindow; + pScreen->ClearToBackground = pScreenPriv->ClearToBackground; + + pScreen->SaveDoomedAreas = pScreenPriv->SaveDoomedAreas; + pScreen->RestoreAreas = pScreenPriv->RestoreAreas; +#ifdef RENDER + if (ps) + { + ps->Composite = pScreenPriv->Composite; + ps->Glyphs = pScreenPriv->Glyphs; + } +#endif + + xfree ((pointer) pScreenPriv); + + return (*pScreen->CloseScreen) (i, pScreen); +} + +static void +rfbSpriteGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine) + DrawablePtr pDrawable; + int sx, sy, w, h; + unsigned int format; + unsigned long planemask; + char *pdstLine; +{ + ScreenPtr pScreen = pDrawable->pScreen; + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, GetImage); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + if (pDrawable->type == DRAWABLE_WINDOW && + pVNC->cursorIsDrawn && + ORG_OVERLAP(&pScreenPriv->saved,pDrawable->x,pDrawable->y, sx, sy, w, h)) + { + rfbSpriteRemoveCursor (pScreen); + } + + (*pScreen->GetImage) (pDrawable, sx, sy, w, h, + format, planemask, pdstLine); + + SCREEN_EPILOGUE (pScreen, GetImage, rfbSpriteGetImage); +} + +static void +rfbSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart) + DrawablePtr pDrawable; + int wMax; + DDXPointPtr ppt; + int *pwidth; + int nspans; + char *pdstStart; +{ + ScreenPtr pScreen = pDrawable->pScreen; + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, GetSpans); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + if (pDrawable->type == DRAWABLE_WINDOW && pVNC->cursorIsDrawn) + { + register DDXPointPtr pts; + register int *widths; + register int nPts; + register int xorg, + yorg; + + xorg = pDrawable->x; + yorg = pDrawable->y; + + for (pts = ppt, widths = pwidth, nPts = nspans; + nPts--; + pts++, widths++) + { + if (SPN_OVERLAP(&pScreenPriv->saved,pts->y+yorg, + pts->x+xorg,*widths)) + { + rfbSpriteRemoveCursor (pScreen); + break; + } + } + } + + (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart); + + SCREEN_EPILOGUE (pScreen, GetSpans, rfbSpriteGetSpans); +} + +static void +rfbSpriteSourceValidate (pDrawable, x, y, width, height) + DrawablePtr pDrawable; + int x, y, width, height; +{ + ScreenPtr pScreen = pDrawable->pScreen; + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, SourceValidate); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + if (pDrawable->type == DRAWABLE_WINDOW && pVNC->cursorIsDrawn && + ORG_OVERLAP(&pScreenPriv->saved, pDrawable->x, pDrawable->y, + x, y, width, height)) + { + rfbSpriteRemoveCursor (pScreen); + } + + if (pScreen->SourceValidate) + (*pScreen->SourceValidate) (pDrawable, x, y, width, height); + + SCREEN_EPILOGUE (pScreen, SourceValidate, rfbSpriteSourceValidate); +} + +static Bool +rfbSpriteCreateGC (pGC) + GCPtr pGC; +{ + ScreenPtr pScreen = pGC->pScreen; + Bool ret; + rfbSpriteGCPtr pPriv; + + SCREEN_PROLOGUE (pScreen, CreateGC); + + pPriv = (rfbSpriteGCPtr)pGC->devPrivates[rfbSpriteGCIndex].ptr; + + ret = (*pScreen->CreateGC) (pGC); + + pPriv->wrapOps = NULL; + pPriv->wrapFuncs = pGC->funcs; + pGC->funcs = &rfbSpriteGCFuncs; + + SCREEN_EPILOGUE (pScreen, CreateGC, rfbSpriteCreateGC); + + return ret; +} + +static void +rfbSpriteBlockHandler (i, blockData, pTimeout, pReadmask) + int i; + pointer blockData; + pointer pTimeout; + pointer pReadmask; +{ + ScreenPtr pScreen = screenInfo.screens[i]; + rfbSpriteScreenPtr pPriv; + VNCSCREENPTR(pScreen); + + pPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + SCREEN_PROLOGUE(pScreen, BlockHandler); + + (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask); + + SCREEN_EPILOGUE(pScreen, BlockHandler, rfbSpriteBlockHandler); + + if (!pVNC->cursorIsDrawn && pPriv->shouldBeUp) + rfbSpriteRestoreCursor (pScreen); +} + +static void +rfbSpriteInstallColormap (pMap) + ColormapPtr pMap; +{ + ScreenPtr pScreen = pMap->pScreen; + rfbSpriteScreenPtr pPriv; + VNCSCREENPTR(pScreen); + + pPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + SCREEN_PROLOGUE(pScreen, InstallColormap); + + (*pScreen->InstallColormap) (pMap); + + SCREEN_EPILOGUE(pScreen, InstallColormap, rfbSpriteInstallColormap); + + pPriv->pInstalledMap = pMap; + if (pPriv->pColormap != pMap) + { + pPriv->checkPixels = TRUE; + if (pVNC->cursorIsDrawn) + rfbSpriteRemoveCursor (pScreen); + } +} + +static void +rfbSpriteStoreColors (pMap, ndef, pdef) + ColormapPtr pMap; + int ndef; + xColorItem *pdef; +{ + ScreenPtr pScreen = pMap->pScreen; + rfbSpriteScreenPtr pPriv; + int i; + int updated; + VisualPtr pVisual; + VNCSCREENPTR(pScreen); + + pPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + SCREEN_PROLOGUE(pScreen, StoreColors); + + (*pScreen->StoreColors) (pMap, ndef, pdef); + + SCREEN_EPILOGUE(pScreen, StoreColors, rfbSpriteStoreColors); + + if (pPriv->pColormap == pMap) + { + updated = 0; + pVisual = pMap->pVisual; + if (pVisual->class == DirectColor) + { + /* Direct color - match on any of the subfields */ + +#define MaskMatch(a,b,mask) ((a) & ((pVisual->mask) == (b)) & (pVisual->mask)) + +#define UpdateDAC(plane,dac,mask) {\ + if (MaskMatch (pPriv->colors[plane].pixel,pdef[i].pixel,mask)) {\ + pPriv->colors[plane].dac = pdef[i].dac; \ + updated = 1; \ + } \ +} + +#define CheckDirect(plane) \ + UpdateDAC(plane,red,redMask) \ + UpdateDAC(plane,green,greenMask) \ + UpdateDAC(plane,blue,blueMask) + + for (i = 0; i < ndef; i++) + { + CheckDirect (SOURCE_COLOR) + CheckDirect (MASK_COLOR) + } + } + else + { + /* PseudoColor/GrayScale - match on exact pixel */ + for (i = 0; i < ndef; i++) + { + if (pdef[i].pixel == pPriv->colors[SOURCE_COLOR].pixel) + { + pPriv->colors[SOURCE_COLOR] = pdef[i]; + if (++updated == 2) + break; + } + if (pdef[i].pixel == pPriv->colors[MASK_COLOR].pixel) + { + pPriv->colors[MASK_COLOR] = pdef[i]; + if (++updated == 2) + break; + } + } + } + if (updated) + { + pPriv->checkPixels = TRUE; + if (pVNC->cursorIsDrawn) + rfbSpriteRemoveCursor (pScreen); + } + } +} + +static void +rfbSpriteFindColors (ScreenPtr pScreen) +{ + rfbSpriteScreenPtr pScreenPriv = (rfbSpriteScreenPtr) + pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + CursorPtr pCursor; + xColorItem *sourceColor, *maskColor; + + pCursor = pScreenPriv->pCursor; + sourceColor = &pScreenPriv->colors[SOURCE_COLOR]; + maskColor = &pScreenPriv->colors[MASK_COLOR]; + if (pScreenPriv->pColormap != pScreenPriv->pInstalledMap || + !(pCursor->foreRed == sourceColor->red && + pCursor->foreGreen == sourceColor->green && + pCursor->foreBlue == sourceColor->blue && + pCursor->backRed == maskColor->red && + pCursor->backGreen == maskColor->green && + pCursor->backBlue == maskColor->blue)) + { + pScreenPriv->pColormap = pScreenPriv->pInstalledMap; + sourceColor->red = pCursor->foreRed; + sourceColor->green = pCursor->foreGreen; + sourceColor->blue = pCursor->foreBlue; + FakeAllocColor (pScreenPriv->pColormap, sourceColor); + maskColor->red = pCursor->backRed; + maskColor->green = pCursor->backGreen; + maskColor->blue = pCursor->backBlue; + FakeAllocColor (pScreenPriv->pColormap, maskColor); + /* "free" the pixels right away, don't let this confuse you */ + FakeFreeColor(pScreenPriv->pColormap, sourceColor->pixel); + FakeFreeColor(pScreenPriv->pColormap, maskColor->pixel); + } + pScreenPriv->checkPixels = FALSE; +} + +/* + * BackingStore wrappers + */ + +static void +rfbSpriteSaveDoomedAreas (pWin, pObscured, dx, dy) + WindowPtr pWin; + RegionPtr pObscured; + int dx, dy; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + BoxRec cursorBox; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, SaveDoomedAreas); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pVNC->cursorIsDrawn) + { + cursorBox = pScreenPriv->saved; + + if (dx || dy) + { + cursorBox.x1 += dx; + cursorBox.y1 += dy; + cursorBox.x2 += dx; + cursorBox.y2 += dy; + } + if (RECT_IN_REGION( pScreen, pObscured, &cursorBox) != rgnOUT) + rfbSpriteRemoveCursor (pScreen); + } + + (*pScreen->SaveDoomedAreas) (pWin, pObscured, dx, dy); + + SCREEN_EPILOGUE (pScreen, SaveDoomedAreas, rfbSpriteSaveDoomedAreas); +} + +static RegionPtr +rfbSpriteRestoreAreas (pWin, prgnExposed) + WindowPtr pWin; + RegionPtr prgnExposed; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + RegionPtr result; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, RestoreAreas); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pVNC->cursorIsDrawn) + { + if (RECT_IN_REGION( pScreen, prgnExposed, &pScreenPriv->saved) != rgnOUT) + rfbSpriteRemoveCursor (pScreen); + } + + result = (*pScreen->RestoreAreas) (pWin, prgnExposed); + + SCREEN_EPILOGUE (pScreen, RestoreAreas, rfbSpriteRestoreAreas); + + return result; +} + +/* + * Window wrappers + */ + +static void +rfbSpritePaintWindowBackground (pWin, pRegion, what) + WindowPtr pWin; + RegionPtr pRegion; + int what; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, PaintWindowBackground); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pVNC->cursorIsDrawn) + { + /* + * If the cursor is on the same screen as the window, check the + * region to paint for the cursor and remove it as necessary + */ + if (RECT_IN_REGION( pScreen, pRegion, &pScreenPriv->saved) != rgnOUT) + rfbSpriteRemoveCursor (pScreen); + } + + (*pScreen->PaintWindowBackground) (pWin, pRegion, what); + + SCREEN_EPILOGUE (pScreen, PaintWindowBackground, rfbSpritePaintWindowBackground); +} + +static void +rfbSpritePaintWindowBorder (pWin, pRegion, what) + WindowPtr pWin; + RegionPtr pRegion; + int what; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, PaintWindowBorder); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pVNC->cursorIsDrawn) + { + /* + * If the cursor is on the same screen as the window, check the + * region to paint for the cursor and remove it as necessary + */ + if (RECT_IN_REGION( pScreen, pRegion, &pScreenPriv->saved) != rgnOUT) + rfbSpriteRemoveCursor (pScreen); + } + + (*pScreen->PaintWindowBorder) (pWin, pRegion, what); + + SCREEN_EPILOGUE (pScreen, PaintWindowBorder, rfbSpritePaintWindowBorder); +} + +static void +rfbSpriteCopyWindow (pWin, ptOldOrg, pRegion) + WindowPtr pWin; + DDXPointRec ptOldOrg; + RegionPtr pRegion; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + BoxRec cursorBox; + int dx, dy; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, CopyWindow); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pVNC->cursorIsDrawn) + { + /* + * check both the source and the destination areas. The given + * region is source relative, so offset the cursor box by + * the delta position + */ + cursorBox = pScreenPriv->saved; + dx = pWin->drawable.x - ptOldOrg.x; + dy = pWin->drawable.y - ptOldOrg.y; + cursorBox.x1 -= dx; + cursorBox.x2 -= dx; + cursorBox.y1 -= dy; + cursorBox.y2 -= dy; + if (RECT_IN_REGION( pScreen, pRegion, &pScreenPriv->saved) != rgnOUT || + RECT_IN_REGION( pScreen, pRegion, &cursorBox) != rgnOUT) + rfbSpriteRemoveCursor (pScreen); + } + + (*pScreen->CopyWindow) (pWin, ptOldOrg, pRegion); + + SCREEN_EPILOGUE (pScreen, CopyWindow, rfbSpriteCopyWindow); +} + +static void +rfbSpriteClearToBackground (pWin, x, y, w, h, generateExposures) + WindowPtr pWin; + short x,y; + unsigned short w,h; + Bool generateExposures; +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + rfbSpriteScreenPtr pScreenPriv; + int realw, realh; + VNCSCREENPTR(pScreen); + + SCREEN_PROLOGUE (pScreen, ClearToBackground); + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (GC_CHECK(pWin)) + { + if (!(realw = w)) + realw = (int) pWin->drawable.width - x; + if (!(realh = h)) + realh = (int) pWin->drawable.height - y; + if (ORG_OVERLAP(&pScreenPriv->saved, pWin->drawable.x, pWin->drawable.y, + x, y, realw, realh)) + { + rfbSpriteRemoveCursor (pScreen); + } + } + + (*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures); + + SCREEN_EPILOGUE (pScreen, ClearToBackground, rfbSpriteClearToBackground); +} + +/* + * GC Func wrappers + */ + +static void +rfbSpriteValidateGC (pGC, changes, pDrawable) + GCPtr pGC; + unsigned long changes; + DrawablePtr pDrawable; +{ + GC_FUNC_PROLOGUE (pGC); + + (*pGC->funcs->ValidateGC) (pGC, changes, pDrawable); + + pGCPriv->wrapOps = NULL; + if (pDrawable->type == DRAWABLE_WINDOW && ((WindowPtr) pDrawable)->viewable) + { + WindowPtr pWin; + RegionPtr pRegion; + + pWin = (WindowPtr) pDrawable; + pRegion = &pWin->clipList; + if (pGC->subWindowMode == IncludeInferiors) + pRegion = &pWin->borderClip; + if (REGION_NOTEMPTY(pDrawable->pScreen, pRegion)) + pGCPriv->wrapOps = pGC->ops; + } + + GC_FUNC_EPILOGUE (pGC); +} + +static void +rfbSpriteChangeGC (pGC, mask) + GCPtr pGC; + unsigned long mask; +{ + GC_FUNC_PROLOGUE (pGC); + + (*pGC->funcs->ChangeGC) (pGC, mask); + + GC_FUNC_EPILOGUE (pGC); +} + +static void +rfbSpriteCopyGC (pGCSrc, mask, pGCDst) + GCPtr pGCSrc, pGCDst; + unsigned long mask; +{ + GC_FUNC_PROLOGUE (pGCDst); + + (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst); + + GC_FUNC_EPILOGUE (pGCDst); +} + +static void +rfbSpriteDestroyGC (pGC) + GCPtr pGC; +{ + GC_FUNC_PROLOGUE (pGC); + + (*pGC->funcs->DestroyGC) (pGC); + + GC_FUNC_EPILOGUE (pGC); +} + +static void +rfbSpriteChangeClip (pGC, type, pvalue, nrects) + GCPtr pGC; + int type; + pointer pvalue; + int nrects; +{ + GC_FUNC_PROLOGUE (pGC); + + (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects); + + GC_FUNC_EPILOGUE (pGC); +} + +static void +rfbSpriteCopyClip(pgcDst, pgcSrc) + GCPtr pgcDst, pgcSrc; +{ + GC_FUNC_PROLOGUE (pgcDst); + + (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc); + + GC_FUNC_EPILOGUE (pgcDst); +} + +static void +rfbSpriteDestroyClip(pGC) + GCPtr pGC; +{ + GC_FUNC_PROLOGUE (pGC); + + (* pGC->funcs->DestroyClip)(pGC); + + GC_FUNC_EPILOGUE (pGC); +} + +/* + * GC Op wrappers + */ + +static void +rfbSpriteFillSpans(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) + DrawablePtr pDrawable; + GCPtr pGC; + int nInit; /* number of spans to fill */ + DDXPointPtr pptInit; /* pointer to list of start points */ + int *pwidthInit; /* pointer to list of n widths */ + int fSorted; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + register DDXPointPtr pts; + register int *widths; + register int nPts; + + for (pts = pptInit, widths = pwidthInit, nPts = nInit; + nPts--; + pts++, widths++) + { + if (SPN_OVERLAP(&pScreenPriv->saved,pts->y,pts->x,*widths)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->FillSpans) (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpriteSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted) + DrawablePtr pDrawable; + GCPtr pGC; + char *psrc; + register DDXPointPtr ppt; + int *pwidth; + int nspans; + int fSorted; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + register DDXPointPtr pts; + register int *widths; + register int nPts; + + for (pts = ppt, widths = pwidth, nPts = nspans; + nPts--; + pts++, widths++) + { + if (SPN_OVERLAP(&pScreenPriv->saved,pts->y,pts->x,*widths)) + { + rfbSpriteRemoveCursor(pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->SetSpans) (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format, pBits) + DrawablePtr pDrawable; + GCPtr pGC; + int depth; + int x; + int y; + int w; + int h; + int format; + char *pBits; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + if (ORG_OVERLAP(&pScreenPriv->saved,pDrawable->x,pDrawable->y, + x,y,w,h)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PutImage) (pDrawable, pGC, depth, x, y, w, h, leftPad, format, pBits); + + GC_OP_EPILOGUE (pGC); +} + +static RegionPtr +rfbSpriteCopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty) + DrawablePtr pSrc; + DrawablePtr pDst; + GCPtr pGC; + int srcx; + int srcy; + int w; + int h; + int dstx; + int dsty; +{ + RegionPtr rgn; + VNCSCREENPTR(pGC->pScreen); + + GC_SETUP(pDst, pGC); + + /* check destination/source overlap. */ + if (GC_CHECK((WindowPtr) pDst) && + (ORG_OVERLAP(&pScreenPriv->saved,pDst->x,pDst->y,dstx,dsty,w,h) || + ((pDst == pSrc) && + ORG_OVERLAP(&pScreenPriv->saved,pSrc->x,pSrc->y,srcx,srcy,w,h)))) + { + rfbSpriteRemoveCursor (pDst->pScreen); + } + + GC_OP_PROLOGUE (pGC); + + rgn = (*pGC->ops->CopyArea) (pSrc, pDst, pGC, srcx, srcy, w, h, + dstx, dsty); + + GC_OP_EPILOGUE (pGC); + + return rgn; +} + +static RegionPtr +rfbSpriteCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane) + DrawablePtr pSrc; + DrawablePtr pDst; + register GCPtr pGC; + int srcx, + srcy; + int w, + h; + int dstx, + dsty; + unsigned long plane; +{ + RegionPtr rgn; + VNCSCREENPTR(pGC->pScreen); + + GC_SETUP(pDst, pGC); + + /* + * check destination/source for overlap. + */ + if (GC_CHECK((WindowPtr) pDst) && + (ORG_OVERLAP(&pScreenPriv->saved,pDst->x,pDst->y,dstx,dsty,w,h) || + ((pDst == pSrc) && + ORG_OVERLAP(&pScreenPriv->saved,pSrc->x,pSrc->y,srcx,srcy,w,h)))) + { + rfbSpriteRemoveCursor (pDst->pScreen); + } + + GC_OP_PROLOGUE (pGC); + + rgn = (*pGC->ops->CopyPlane) (pSrc, pDst, pGC, srcx, srcy, w, h, + dstx, dsty, plane); + + GC_OP_EPILOGUE (pGC); + + return rgn; +} + +static void +rfbSpritePolyPoint (pDrawable, pGC, mode, npt, pptInit) + DrawablePtr pDrawable; + GCPtr pGC; + int mode; /* Origin or Previous */ + int npt; + xPoint *pptInit; +{ + xPoint t; + int n; + BoxRec cursor; + register xPoint *pts; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + if (npt && GC_CHECK((WindowPtr) pDrawable)) + { + cursor.x1 = pScreenPriv->saved.x1 - pDrawable->x; + cursor.y1 = pScreenPriv->saved.y1 - pDrawable->y; + cursor.x2 = pScreenPriv->saved.x2 - pDrawable->x; + cursor.y2 = pScreenPriv->saved.y2 - pDrawable->y; + + if (mode == CoordModePrevious) + { + t.x = 0; + t.y = 0; + for (pts = pptInit, n = npt; n--; pts++) + { + t.x += pts->x; + t.y += pts->y; + if (cursor.x1 <= t.x && t.x <= cursor.x2 && + cursor.y1 <= t.y && t.y <= cursor.y2) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + else + { + for (pts = pptInit, n = npt; n--; pts++) + { + if (cursor.x1 <= pts->x && pts->x <= cursor.x2 && + cursor.y1 <= pts->y && pts->y <= cursor.y2) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolyPoint) (pDrawable, pGC, mode, npt, pptInit); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolylines (pDrawable, pGC, mode, npt, pptInit) + DrawablePtr pDrawable; + GCPtr pGC; + int mode; + int npt; + DDXPointPtr pptInit; +{ + BoxPtr cursor; + register DDXPointPtr pts; + int n; + int x, y, x1, y1, x2, y2; + int lw; + int extra; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + if (npt && GC_CHECK((WindowPtr) pDrawable)) + { + cursor = &pScreenPriv->saved; + lw = pGC->lineWidth; + x = pptInit->x + pDrawable->x; + y = pptInit->y + pDrawable->y; + + if (npt == 1) + { + extra = lw >> 1; + if (LINE_OVERLAP(cursor, x, y, x, y, extra)) + rfbSpriteRemoveCursor (pDrawable->pScreen); + } + else + { + extra = lw >> 1; + /* + * mitered joins can project quite a way from + * the line end; the 11 degree miter limit limits + * this extension to 10.43 * lw / 2, rounded up + * and converted to int yields 6 * lw + */ + if (pGC->joinStyle == JoinMiter) + extra = 6 * lw; + else if (pGC->capStyle == CapProjecting) + extra = lw; + for (pts = pptInit + 1, n = npt - 1; n--; pts++) + { + x1 = x; + y1 = y; + if (mode == CoordModeOrigin) + { + x2 = pDrawable->x + pts->x; + y2 = pDrawable->y + pts->y; + } + else + { + x2 = x + pts->x; + y2 = y + pts->y; + } + x = x2; + y = y2; + LINE_SORT(x1, y1, x2, y2); + if (LINE_OVERLAP(cursor, x1, y1, x2, y2, extra)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + } + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->Polylines) (pDrawable, pGC, mode, npt, pptInit); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolySegment(pDrawable, pGC, nseg, pSegs) + DrawablePtr pDrawable; + GCPtr pGC; + int nseg; + xSegment *pSegs; +{ + int n; + register xSegment *segs; + BoxPtr cursor; + int x1, y1, x2, y2; + int extra; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (nseg && GC_CHECK((WindowPtr) pDrawable)) + { + cursor = &pScreenPriv->saved; + extra = pGC->lineWidth >> 1; + if (pGC->capStyle == CapProjecting) + extra = pGC->lineWidth; + for (segs = pSegs, n = nseg; n--; segs++) + { + x1 = segs->x1 + pDrawable->x; + y1 = segs->y1 + pDrawable->y; + x2 = segs->x2 + pDrawable->x; + y2 = segs->y2 + pDrawable->y; + LINE_SORT(x1, y1, x2, y2); + if (LINE_OVERLAP(cursor, x1, y1, x2, y2, extra)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolySegment) (pDrawable, pGC, nseg, pSegs); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolyRectangle(pDrawable, pGC, nrects, pRects) + DrawablePtr pDrawable; + GCPtr pGC; + int nrects; + xRectangle *pRects; +{ + register xRectangle *rects; + BoxPtr cursor; + int lw; + int n; + int x1, y1, x2, y2; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + lw = pGC->lineWidth >> 1; + cursor = &pScreenPriv->saved; + for (rects = pRects, n = nrects; n--; rects++) + { + x1 = rects->x + pDrawable->x; + y1 = rects->y + pDrawable->y; + x2 = x1 + (int)rects->width; + y2 = y1 + (int)rects->height; + if (LINE_OVERLAP(cursor, x1, y1, x2, y1, lw) || + LINE_OVERLAP(cursor, x2, y1, x2, y2, lw) || + LINE_OVERLAP(cursor, x1, y2, x2, y2, lw) || + LINE_OVERLAP(cursor, x1, y1, x1, y2, lw)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolyRectangle) (pDrawable, pGC, nrects, pRects); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolyArc(pDrawable, pGC, narcs, parcs) + DrawablePtr pDrawable; + register GCPtr pGC; + int narcs; + xArc *parcs; +{ + BoxPtr cursor; + int lw; + int n; + register xArc *arcs; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + lw = pGC->lineWidth >> 1; + cursor = &pScreenPriv->saved; + for (arcs = parcs, n = narcs; n--; arcs++) + { + if (ORG_OVERLAP (cursor, pDrawable->x, pDrawable->y, + arcs->x - lw, arcs->y - lw, + (int) arcs->width + pGC->lineWidth, + (int) arcs->height + pGC->lineWidth)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolyArc) (pDrawable, pGC, narcs, parcs); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpriteFillPolygon(pDrawable, pGC, shape, mode, count, pPts) + register DrawablePtr pDrawable; + register GCPtr pGC; + int shape, mode; + int count; + DDXPointPtr pPts; +{ + int x, y, minx, miny, maxx, maxy; + register DDXPointPtr pts; + int n; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + if (count && GC_CHECK((WindowPtr) pDrawable)) + { + x = pDrawable->x; + y = pDrawable->y; + pts = pPts; + minx = maxx = pts->x; + miny = maxy = pts->y; + pts++; + n = count - 1; + + if (mode == CoordModeOrigin) + { + for (; n--; pts++) + { + if (pts->x < minx) + minx = pts->x; + else if (pts->x > maxx) + maxx = pts->x; + if (pts->y < miny) + miny = pts->y; + else if (pts->y > maxy) + maxy = pts->y; + } + minx += x; + miny += y; + maxx += x; + maxy += y; + } + else + { + x += minx; + y += miny; + minx = maxx = x; + miny = maxy = y; + for (; n--; pts++) + { + x += pts->x; + y += pts->y; + if (x < minx) + minx = x; + else if (x > maxx) + maxx = x; + if (y < miny) + miny = y; + else if (y > maxy) + maxy = y; + } + } + if (BOX_OVERLAP(&pScreenPriv->saved,minx,miny,maxx,maxy)) + rfbSpriteRemoveCursor (pDrawable->pScreen); + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->FillPolygon) (pDrawable, pGC, shape, mode, count, pPts); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolyFillRect(pDrawable, pGC, nrectFill, prectInit) + DrawablePtr pDrawable; + GCPtr pGC; + int nrectFill; /* number of rectangles to fill */ + xRectangle *prectInit; /* Pointer to first rectangle to fill */ +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + register int nRect; + register xRectangle *pRect; + register int xorg, yorg; + + xorg = pDrawable->x; + yorg = pDrawable->y; + + for (nRect = nrectFill, pRect = prectInit; nRect--; pRect++) { + if (ORGRECT_OVERLAP(&pScreenPriv->saved,xorg,yorg,pRect)){ + rfbSpriteRemoveCursor(pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolyFillRect) (pDrawable, pGC, nrectFill, prectInit); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolyFillArc(pDrawable, pGC, narcs, parcs) + DrawablePtr pDrawable; + GCPtr pGC; + int narcs; + xArc *parcs; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + { + register int n; + BoxPtr cursor; + register xArc *arcs; + + cursor = &pScreenPriv->saved; + + for (arcs = parcs, n = narcs; n--; arcs++) + { + if (ORG_OVERLAP(cursor, pDrawable->x, pDrawable->y, + arcs->x, arcs->y, + (int) arcs->width, (int) arcs->height)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + break; + } + } + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PolyFillArc) (pDrawable, pGC, narcs, parcs); + + GC_OP_EPILOGUE (pGC); +} + +/* + * general Poly/Image text function. Extract glyph information, + * compute bounding box and remove cursor if it is overlapped. + */ + +static Bool +rfbSpriteTextOverlap (DrawablePtr pDraw, FontPtr font, int x, int y, unsigned int n, CharInfoPtr *charinfo, Bool imageblt, unsigned int w, BoxPtr cursorBox) +{ + ExtentInfoRec extents; + + x += pDraw->x; + y += pDraw->y; + + if (FONTMINBOUNDS(font,characterWidth) >= 0) + { + /* compute an approximate (but covering) bounding box */ + if (!imageblt || (charinfo[0]->metrics.leftSideBearing < 0)) + extents.overallLeft = charinfo[0]->metrics.leftSideBearing; + else + extents.overallLeft = 0; + if (w) + extents.overallRight = w - charinfo[n-1]->metrics.characterWidth; + else + extents.overallRight = FONTMAXBOUNDS(font,characterWidth) + * (n - 1); + if (imageblt && (charinfo[n-1]->metrics.characterWidth > + charinfo[n-1]->metrics.rightSideBearing)) + extents.overallRight += charinfo[n-1]->metrics.characterWidth; + else + extents.overallRight += charinfo[n-1]->metrics.rightSideBearing; + if (imageblt && FONTASCENT(font) > FONTMAXBOUNDS(font,ascent)) + extents.overallAscent = FONTASCENT(font); + else + extents.overallAscent = FONTMAXBOUNDS(font, ascent); + if (imageblt && FONTDESCENT(font) > FONTMAXBOUNDS(font,descent)) + extents.overallDescent = FONTDESCENT(font); + else + extents.overallDescent = FONTMAXBOUNDS(font,descent); + if (!BOX_OVERLAP(cursorBox, + x + extents.overallLeft, + y - extents.overallAscent, + x + extents.overallRight, + y + extents.overallDescent)) + return FALSE; + else if (imageblt && w) + return TRUE; + /* if it does overlap, fall through and compute exactly, because + * taking down the cursor is expensive enough to make this worth it + */ + } + QueryGlyphExtents(font, charinfo, n, &extents); + if (imageblt) + { + if (extents.overallWidth > extents.overallRight) + extents.overallRight = extents.overallWidth; + if (extents.overallWidth < extents.overallLeft) + extents.overallLeft = extents.overallWidth; + if (extents.overallLeft > 0) + extents.overallLeft = 0; + if (extents.fontAscent > extents.overallAscent) + extents.overallAscent = extents.fontAscent; + if (extents.fontDescent > extents.overallDescent) + extents.overallDescent = extents.fontDescent; + } + return (BOX_OVERLAP(cursorBox, + x + extents.overallLeft, + y - extents.overallAscent, + x + extents.overallRight, + y + extents.overallDescent)); +} + +/* + * values for textType: + */ +#define TT_POLY8 0 +#define TT_IMAGE8 1 +#define TT_POLY16 2 +#define TT_IMAGE16 3 + +static int +rfbSpriteText (DrawablePtr pDraw, GCPtr pGC, int x, int y, unsigned long count, char *chars, FontEncoding fontEncoding, Bool textType, BoxPtr cursorBox) +{ + CharInfoPtr *charinfo; + register CharInfoPtr *info; + unsigned long i; + unsigned int n; + int w; + void (*drawFunc)() = NULL; + + Bool imageblt; + + imageblt = (textType == TT_IMAGE8) || (textType == TT_IMAGE16); + + charinfo = (CharInfoPtr *) ALLOCATE_LOCAL(count * sizeof(CharInfoPtr)); + if (!charinfo) + return x; + + GetGlyphs(pGC->font, count, (unsigned char *)chars, + fontEncoding, &i, charinfo); + n = (unsigned int)i; + w = 0; + if (!imageblt) + for (info = charinfo; i--; info++) + w += (*info)->metrics.characterWidth; + + if (n != 0) { + if (rfbSpriteTextOverlap(pDraw, pGC->font, x, y, n, charinfo, imageblt, w, cursorBox)) + rfbSpriteRemoveCursor(pDraw->pScreen); + +#ifdef AVOID_GLYPHBLT + /* + * On displays like Apollos, which do not optimize the GlyphBlt functions because they + * convert fonts to their internal form in RealizeFont and optimize text directly, we + * want to invoke the text functions here, not the GlyphBlt functions. + */ + switch (textType) + { + case TT_POLY8: + drawFunc = (void (*)())pGC->ops->PolyText8; + break; + case TT_IMAGE8: + drawFunc = pGC->ops->ImageText8; + break; + case TT_POLY16: + drawFunc = (void (*)())pGC->ops->PolyText16; + break; + case TT_IMAGE16: + drawFunc = pGC->ops->ImageText16; + break; + } + (*drawFunc) (pDraw, pGC, x, y, (int) count, chars); +#else /* don't AVOID_GLYPHBLT */ + /* + * On the other hand, if the device does use GlyphBlt ultimately to do text, we + * don't want to slow it down by invoking the text functions and having them call + * GetGlyphs all over again, so we go directly to the GlyphBlt functions here. + */ + drawFunc = imageblt ? pGC->ops->ImageGlyphBlt : pGC->ops->PolyGlyphBlt; + (*drawFunc) (pDraw, pGC, x, y, n, charinfo, FONTGLYPHS(pGC->font)); +#endif /* AVOID_GLYPHBLT */ + } + DEALLOCATE_LOCAL(charinfo); + return x + w; +} + +static int +rfbSpritePolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars) +{ + int ret; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + ret = rfbSpriteText (pDrawable, pGC, x, y, (unsigned long)count, chars, + Linear8Bit, TT_POLY8, &pScreenPriv->saved); + else + ret = (*pGC->ops->PolyText8) (pDrawable, pGC, x, y, count, chars); + + GC_OP_EPILOGUE (pGC); + return ret; +} + +static int +rfbSpritePolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars) +{ + int ret; + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + ret = rfbSpriteText (pDrawable, pGC, x, y, (unsigned long)count, + (char *)chars, + FONTLASTROW(pGC->font) == 0 ? + Linear16Bit : TwoD16Bit, TT_POLY16, &pScreenPriv->saved); + else + ret = (*pGC->ops->PolyText16) (pDrawable, pGC, x, y, count, chars); + + GC_OP_EPILOGUE (pGC); + return ret; +} + +static void +rfbSpriteImageText8(pDrawable, pGC, x, y, count, chars) + DrawablePtr pDrawable; + GCPtr pGC; + int x, y; + int count; + char *chars; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + (void) rfbSpriteText (pDrawable, pGC, x, y, (unsigned long)count, + chars, Linear8Bit, TT_IMAGE8, &pScreenPriv->saved); + else + (*pGC->ops->ImageText8) (pDrawable, pGC, x, y, count, chars); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpriteImageText16(pDrawable, pGC, x, y, count, chars) + DrawablePtr pDrawable; + GCPtr pGC; + int x, y; + int count; + unsigned short *chars; +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable)) + (void) rfbSpriteText (pDrawable, pGC, x, y, (unsigned long)count, + (char *)chars, + FONTLASTROW(pGC->font) == 0 ? + Linear16Bit : TwoD16Bit, TT_IMAGE16, &pScreenPriv->saved); + else + (*pGC->ops->ImageText16) (pDrawable, pGC, x, y, count, chars); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpriteImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase) + DrawablePtr pDrawable; + GCPtr pGC; + int x, y; + unsigned int nglyph; + CharInfoPtr *ppci; /* array of character info */ + pointer pglyphBase; /* start of array of glyphs */ +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP(pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable) && + rfbSpriteTextOverlap (pDrawable, pGC->font, x, y, nglyph, ppci, TRUE, 0, &pScreenPriv->saved)) + { + rfbSpriteRemoveCursor(pDrawable->pScreen); + } + (*pGC->ops->ImageGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase) + DrawablePtr pDrawable; + GCPtr pGC; + int x, y; + unsigned int nglyph; + CharInfoPtr *ppci; /* array of character info */ + pointer pglyphBase; /* start of array of glyphs */ +{ + VNCSCREENPTR(pDrawable->pScreen); + + GC_SETUP (pDrawable, pGC); + + GC_OP_PROLOGUE (pGC); + + if (GC_CHECK((WindowPtr) pDrawable) && + rfbSpriteTextOverlap (pDrawable, pGC->font, x, y, nglyph, ppci, FALSE, 0, &pScreenPriv->saved)) + { + rfbSpriteRemoveCursor(pDrawable->pScreen); + } + (*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); + + GC_OP_EPILOGUE (pGC); +} + +static void +rfbSpritePushPixels(pGC, pBitMap, pDrawable, w, h, x, y) + GCPtr pGC; + PixmapPtr pBitMap; + DrawablePtr pDrawable; + int w, h, x, y; +{ + VNCSCREENPTR(pDrawable->pScreen); + GC_SETUP(pDrawable, pGC); + + if (GC_CHECK((WindowPtr) pDrawable) && + ORG_OVERLAP(&pScreenPriv->saved,pDrawable->x,pDrawable->y,x,y,w,h)) + { + rfbSpriteRemoveCursor (pDrawable->pScreen); + } + + GC_OP_PROLOGUE (pGC); + + (*pGC->ops->PushPixels) (pGC, pBitMap, pDrawable, w, h, x, y); + + GC_OP_EPILOGUE (pGC); +} + +#ifdef NEED_LINEHELPER +/* + * I don't expect this routine will ever be called, as the GC + * will have been unwrapped for the line drawing + */ + +static void +rfbSpriteLineHelper() +{ + FatalError("rfbSpriteLineHelper called\n"); +} +#endif + +#ifdef RENDER + +# define mod(a,b) ((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b)) + +static void +rfbSpritePictureOverlap (PicturePtr pPict, + INT16 x, + INT16 y, + CARD16 w, + CARD16 h) +{ + VNCSCREENPTR(pPict->pDrawable->pScreen); + + if (pPict->pDrawable->type == DRAWABLE_WINDOW) + { + WindowPtr pWin = (WindowPtr) (pPict->pDrawable); + rfbSpriteScreenPtr pScreenPriv = (rfbSpriteScreenPtr) + pPict->pDrawable->pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (GC_CHECK(pWin)) + { + if (pPict->repeat) + { + x = mod(x,pWin->drawable.width); + y = mod(y,pWin->drawable.height); + } + if (ORG_OVERLAP (&pScreenPriv->saved, pWin->drawable.x, pWin->drawable.y, + x, y, w, h)) + rfbSpriteRemoveCursor (pWin->drawable.pScreen); + } + } +} + +#define PICTURE_PROLOGUE(ps, pScreenPriv, field) \ + ps->field = pScreenPriv->field + +#define PICTURE_EPILOGUE(ps, field, wrap) \ + ps->field = wrap + +static void +rfbSpriteComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + PICTURE_PROLOGUE(ps, pScreenPriv, Composite); + rfbSpritePictureOverlap (pSrc, xSrc, ySrc, width, height); + if (pMask) + rfbSpritePictureOverlap (pMask, xMask, yMask, width, height); + rfbSpritePictureOverlap (pDst, xDst, yDst, width, height); + + (*ps->Composite) (op, + pSrc, + pMask, + pDst, + xSrc, + ySrc, + xMask, + yMask, + xDst, + yDst, + width, + height); + + PICTURE_EPILOGUE(ps, Composite, rfbSpriteComposite); +} + +static void +rfbSpriteGlyphs(CARD8 op, + PicturePtr pSrc, + PicturePtr pDst, + PictFormatPtr maskFormat, + INT16 xSrc, + INT16 ySrc, + int nlist, + GlyphListPtr list, + GlyphPtr *glyphs) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + VNCSCREENPTR(pScreen); + PictureScreenPtr ps = GetPictureScreen(pScreen); + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + PICTURE_PROLOGUE(ps, pScreenPriv, Glyphs); + if (pSrc->pDrawable->type == DRAWABLE_WINDOW) + { + WindowPtr pSrcWin = (WindowPtr) (pSrc->pDrawable); + + if (GC_CHECK(pSrcWin)) + rfbSpriteRemoveCursor (pScreen); + } + if (pDst->pDrawable->type == DRAWABLE_WINDOW) + { + WindowPtr pDstWin = (WindowPtr) (pDst->pDrawable); + + if (GC_CHECK(pDstWin)) + { + BoxRec extents; + + miGlyphExtents (nlist, list, glyphs, &extents); + if (BOX_OVERLAP(&pScreenPriv->saved, + extents.x1 + pDstWin->drawable.x, + extents.y1 + pDstWin->drawable.y, + extents.x2 + pDstWin->drawable.x, + extents.y2 + pDstWin->drawable.y)) + { + rfbSpriteRemoveCursor (pScreen); + } + } + } + + (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs); + + PICTURE_EPILOGUE (ps, Glyphs, rfbSpriteGlyphs); +} +#endif + +/* + * miPointer interface routines + */ + +#define SPRITE_PAD 8 + +static Bool +rfbSpriteRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor) +{ + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (pCursor == pScreenPriv->pCursor) + pScreenPriv->checkPixels = TRUE; + return (*pScreenPriv->funcs->RealizeCursor) (pScreen, pCursor); +} + +static Bool +rfbSpriteUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor) +{ + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + return (*pScreenPriv->funcs->UnrealizeCursor) (pScreen, pCursor); +} + +static void +rfbSpriteSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y) +{ + rfbSpriteScreenPtr pScreenPriv; + rfbClientPtr cl, nextCl; + VNCSCREENPTR(pScreen); + + pScreenPriv + = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + if (!pCursor) + { + pScreenPriv->shouldBeUp = FALSE; + if (pVNC->cursorIsDrawn) + rfbSpriteRemoveCursor (pScreen); + pScreenPriv->pCursor = 0; + return; + } + pScreenPriv->shouldBeUp = TRUE; + if (pScreenPriv->x == x && + pScreenPriv->y == y && + pScreenPriv->pCursor == pCursor && + !pScreenPriv->checkPixels) + { + return; + } + pScreenPriv->x = x; + pScreenPriv->y = y; + pScreenPriv->pCacheWin = NullWindow; + if (pScreenPriv->checkPixels || pScreenPriv->pCursor != pCursor) + { + pScreenPriv->pCursor = pCursor; + rfbSpriteFindColors (pScreen); + } + if (pVNC->cursorIsDrawn) { + int sx, sy; + /* + * check to see if the old saved region + * encloses the new sprite, in which case we use + * the flicker-free MoveCursor primitive. + */ + sx = pScreenPriv->x - (int)pCursor->bits->xhot; + sy = pScreenPriv->y - (int)pCursor->bits->yhot; + if (sx + (int) pCursor->bits->width >= pScreenPriv->saved.x1 && + sx < pScreenPriv->saved.x2 && + sy + (int) pCursor->bits->height >= pScreenPriv->saved.y1 && + sy < pScreenPriv->saved.y2 && + (int) pCursor->bits->width + (2 * SPRITE_PAD) == + pScreenPriv->saved.x2 - pScreenPriv->saved.x1 && + (int) pCursor->bits->height + (2 * SPRITE_PAD) == + pScreenPriv->saved.y2 - pScreenPriv->saved.y1 + ) + { + pVNC->cursorIsDrawn = FALSE; + if (!(sx >= pScreenPriv->saved.x1 && + sx + (int)pCursor->bits->width < pScreenPriv->saved.x2 && + sy >= pScreenPriv->saved.y1 && + sy + (int)pCursor->bits->height < pScreenPriv->saved.y2)) + { + int oldx1, oldy1, dx, dy; + + oldx1 = pScreenPriv->saved.x1; + oldy1 = pScreenPriv->saved.y1; + dx = oldx1 - (sx - SPRITE_PAD); + dy = oldy1 - (sy - SPRITE_PAD); + pScreenPriv->saved.x1 -= dx; + pScreenPriv->saved.y1 -= dy; + pScreenPriv->saved.x2 -= dx; + pScreenPriv->saved.y2 -= dy; + (void) (*pScreenPriv->funcs->ChangeSave) (pScreen, + pScreenPriv->saved.x1, + pScreenPriv->saved.y1, + pScreenPriv->saved.x2 - pScreenPriv->saved.x1, + pScreenPriv->saved.y2 - pScreenPriv->saved.y1, + dx, dy); + } + (void) (*pScreenPriv->funcs->MoveCursor) (pScreen, pCursor, + pScreenPriv->saved.x1, + pScreenPriv->saved.y1, + pScreenPriv->saved.x2 - pScreenPriv->saved.x1, + pScreenPriv->saved.y2 - pScreenPriv->saved.y1, + sx - pScreenPriv->saved.x1, + sy - pScreenPriv->saved.y1, + pScreenPriv->colors[SOURCE_COLOR].pixel, + pScreenPriv->colors[MASK_COLOR].pixel); + pVNC->cursorIsDrawn = TRUE; + } + else + { + rfbSpriteRemoveCursor (pScreen); + } + } +#if 0 + if (!pVNC->cursorIsDrawn && pScreenPriv->pCursor) + rfbSpriteRestoreCursor (pScreen); +#endif + if (pVNC->cursorIsDrawn) + rfbSpriteRemoveCursor (pScreen); + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + if (cl->enableCursorPosUpdates) { + if (x == cl->cursorX && y == cl->cursorY) { + cl->cursorWasMoved = FALSE; + continue; + } + cl->cursorWasMoved = TRUE; + } + if (REGION_NOTEMPTY(pScreen,&cl->requestedRegion)) { + /* cursorIsDrawn is guaranteed to be FALSE here, so we definitely + want to send a screen update to the client, even if that's only + putting up the cursor */ + rfbSendFramebufferUpdate(pScreen, cl); + } + } +} + +static void +rfbSpriteMoveCursor (ScreenPtr pScreen, int x, int y) +{ + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + rfbSpriteSetCursor (pScreen, pScreenPriv->pCursor, x, y); +} + +/* + * undraw/draw cursor + */ + +void +rfbSpriteRemoveCursor (pScreen) + ScreenPtr pScreen; +{ + rfbSpriteScreenPtr pScreenPriv; + VNCSCREENPTR(pScreen); + + if (!pVNC->cursorIsDrawn) + return; + + pScreenPriv + = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + pVNC->dontSendFramebufferUpdate = TRUE; + pVNC->cursorIsDrawn = FALSE; + pScreenPriv->pCacheWin = NullWindow; + if (!(*pScreenPriv->funcs->RestoreUnderCursor) (pScreen, + pScreenPriv->saved.x1, + pScreenPriv->saved.y1, + pScreenPriv->saved.x2 - pScreenPriv->saved.x1, + pScreenPriv->saved.y2 - pScreenPriv->saved.y1)) + { + pVNC->cursorIsDrawn = TRUE; + } + pVNC->dontSendFramebufferUpdate = FALSE; +} + + +void +rfbSpriteRestoreCursor (pScreen) + ScreenPtr pScreen; +{ + rfbSpriteScreenPtr pScreenPriv; + int x, y; + CursorPtr pCursor; + VNCSCREENPTR(pScreen); + + pScreenPriv + = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + pCursor = pScreenPriv->pCursor; + + if (pVNC->cursorIsDrawn || !pCursor) + return; + + pVNC->dontSendFramebufferUpdate = TRUE; + + rfbSpriteComputeSaved (pScreen); + + x = pScreenPriv->x - (int)pCursor->bits->xhot; + y = pScreenPriv->y - (int)pCursor->bits->yhot; + if ((*pScreenPriv->funcs->SaveUnderCursor) (pScreen, + pScreenPriv->saved.x1, + pScreenPriv->saved.y1, + pScreenPriv->saved.x2 - pScreenPriv->saved.x1, + pScreenPriv->saved.y2 - pScreenPriv->saved.y1)) + { + if (pScreenPriv->checkPixels) + rfbSpriteFindColors (pScreen); + if ((*pScreenPriv->funcs->PutUpCursor) (pScreen, pCursor, x, y, + pScreenPriv->colors[SOURCE_COLOR].pixel, + pScreenPriv->colors[MASK_COLOR].pixel)) + pVNC->cursorIsDrawn = TRUE; + } + + pVNC->dontSendFramebufferUpdate = FALSE; +} + +/* + * compute the desired area of the screen to save + */ + +static void +rfbSpriteComputeSaved (pScreen) + ScreenPtr pScreen; +{ + rfbSpriteScreenPtr pScreenPriv; + int x, y, w, h; + int wpad, hpad; + CursorPtr pCursor; + + pScreenPriv = (rfbSpriteScreenPtr) pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + pCursor = pScreenPriv->pCursor; + x = pScreenPriv->x - (int)pCursor->bits->xhot; + y = pScreenPriv->y - (int)pCursor->bits->yhot; + w = pCursor->bits->width; + h = pCursor->bits->height; + wpad = SPRITE_PAD; + hpad = SPRITE_PAD; + pScreenPriv->saved.x1 = x - wpad; + pScreenPriv->saved.y1 = y - hpad; + pScreenPriv->saved.x2 = pScreenPriv->saved.x1 + w + wpad * 2; + pScreenPriv->saved.y2 = pScreenPriv->saved.y1 + h + hpad * 2; +} + + +/* + * this function is called when the cursor shape is being changed + */ + +static Bool +rfbDisplayCursor(pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + rfbClientPtr cl; + rfbSpriteScreenPtr pPriv; + Bool status; + + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (cl->enableCursorShapeUpdates) + cl->cursorWasChanged = TRUE; + } + + pPriv = (rfbSpriteScreenPtr)pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + status = (*pPriv->DisplayCursor)(pScreen, pCursor); + + /* send new cursor shape to interested viewers */ + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (cl->cursorWasChanged) { + rfbSendFramebufferUpdate(pScreen, cl); + } + } + + return status; +} + + +/* + * obtain current cursor pointer + */ + +CursorPtr +rfbSpriteGetCursorPtr (pScreen) + ScreenPtr pScreen; +{ + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) + pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + return pScreenPriv->pCursor; +} + +/* + * obtain current cursor position + */ + +void +rfbSpriteGetCursorPos (pScreen, px, py) + ScreenPtr pScreen; + int *px, *py; +{ + rfbSpriteScreenPtr pScreenPriv; + + pScreenPriv = (rfbSpriteScreenPtr) + pScreen->devPrivates[rfbSpriteScreenIndex].ptr; + + *px = pScreenPriv->x; + *py = pScreenPriv->y; +} + diff -pNur xorg-server-1.4.orig/hw/vnc/sprite.h xorg-server-1.4/hw/vnc/sprite.h --- xorg-server-1.4.orig/hw/vnc/sprite.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/sprite.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,141 @@ +/* + * sprite.h + * + * software-sprite/sprite drawing - based on misprite + * + * 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) 1989 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. +*/ + +typedef struct { + Bool (*RealizeCursor)( + ScreenPtr /*pScreen*/, + CursorPtr /*pCursor*/ +); + Bool (*UnrealizeCursor)( + ScreenPtr /*pScreen*/, + CursorPtr /*pCursor*/ +); + Bool (*PutUpCursor)( + ScreenPtr /*pScreen*/, + CursorPtr /*pCursor*/, + int /*x*/, + int /*y*/, + unsigned long /*source*/, + unsigned long /*mask*/ +); + Bool (*SaveUnderCursor)( + ScreenPtr /*pScreen*/, + int /*x*/, + int /*y*/, + int /*w*/, + int /*h*/ +); + Bool (*RestoreUnderCursor)( + ScreenPtr /*pScreen*/, + int /*x*/, + int /*y*/, + int /*w*/, + int /*h*/ +); + Bool (*MoveCursor)( + ScreenPtr /*pScreen*/, + CursorPtr /*pCursor*/, + int /*x*/, + int /*y*/, + int /*w*/, + int /*h*/, + int /*dx*/, + int /*dy*/, + unsigned long /*source*/, + unsigned long /*mask*/ +); + Bool (*ChangeSave)( + ScreenPtr /*pScreen*/, + int /*x*/, + int /*y*/, + int /*w*/, + int /*h*/, + int /*dx*/, + int /*dy*/ +); + +} rfbSpriteCursorFuncRec, *rfbSpriteCursorFuncPtr; + +extern Bool rfbSpriteInitialize( +#if NeedFunctionPrototypes + ScreenPtr /*pScreen*/, + rfbSpriteCursorFuncPtr /*cursorFuncs*/, + miPointerScreenFuncPtr /*screenFuncs*/ +#endif +); + +extern void rfbSpriteRestoreCursor( +#if NeedFunctionPrototypes + ScreenPtr /*pScreen*/ +#endif +); + +extern void rfbSpriteRemoveCursor( +#if NeedFunctionPrototypes + ScreenPtr /*pScreen*/ +#endif +); + +extern CursorPtr rfbSpriteGetCursorPtr( +#if NeedFunctionPrototypes + ScreenPtr /*pScreen*/ +#endif +); + +extern void rfbSpriteGetCursorPos( +#if NeedFunctionPrototypes + ScreenPtr /*pScreen*/, + int * /*px*/, + int * /*py*/ +#endif +); diff -pNur xorg-server-1.4.orig/hw/vnc/spritest.h xorg-server-1.4/hw/vnc/spritest.h --- xorg-server-1.4.orig/hw/vnc/spritest.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/spritest.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,138 @@ +/* + * spritest.h + * + * sprite structures - based on misprite + * + * 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) 1989 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. +*/ + +# include "sprite.h" + +#ifdef RENDER +# include "picturestr.h" +#endif + +/* + * per screen information + */ + +typedef struct { + CloseScreenProcPtr CloseScreen; + GetImageProcPtr GetImage; + GetSpansProcPtr GetSpans; + SourceValidateProcPtr SourceValidate; + CreateGCProcPtr CreateGC; + ScreenBlockHandlerProcPtr BlockHandler; + InstallColormapProcPtr InstallColormap; + StoreColorsProcPtr StoreColors; + PaintWindowBackgroundProcPtr PaintWindowBackground; + PaintWindowBorderProcPtr PaintWindowBorder; + CopyWindowProcPtr CopyWindow; + ClearToBackgroundProcPtr ClearToBackground; + SaveDoomedAreasProcPtr SaveDoomedAreas; + RestoreAreasProcPtr RestoreAreas; + DisplayCursorProcPtr DisplayCursor; +#ifdef RENDER + CompositeProcPtr Composite; + GlyphsProcPtr Glyphs; +#endif + + CursorPtr pCursor; + int x; + int y; + Bool shouldBeUp; + BoxRec saved; + WindowPtr pCacheWin; + Bool isInCacheWin; + Bool checkPixels; + xColorItem colors[2]; + ColormapPtr pInstalledMap; + ColormapPtr pColormap; + VisualPtr pVisual; + rfbSpriteCursorFuncPtr funcs; +} rfbSpriteScreenRec, *rfbSpriteScreenPtr; + +#define SOURCE_COLOR 0 +#define MASK_COLOR 1 + +typedef struct { + GCFuncs *wrapFuncs; + GCOps *wrapOps; +} rfbSpriteGCRec, *rfbSpriteGCPtr; + +/* + * Overlap BoxPtr and Box elements + */ +#define BOX_OVERLAP(pCbox,X1,Y1,X2,Y2) \ + (((pCbox)->x1 <= (X2)) && ((X1) <= (pCbox)->x2) && \ + ((pCbox)->y1 <= (Y2)) && ((Y1) <= (pCbox)->y2)) + +/* + * Overlap BoxPtr, origins, and rectangle + */ +#define ORG_OVERLAP(pCbox,xorg,yorg,x,y,w,h) \ + BOX_OVERLAP((pCbox),(x)+(xorg),(y)+(yorg),(x)+(xorg)+(w),(y)+(yorg)+(h)) + +/* + * Overlap BoxPtr, origins and RectPtr + */ +#define ORGRECT_OVERLAP(pCbox,xorg,yorg,pRect) \ + ORG_OVERLAP((pCbox),(xorg),(yorg),(pRect)->x,(pRect)->y, \ + (int)((pRect)->width), (int)((pRect)->height)) +/* + * Overlap BoxPtr and horizontal span + */ +#define SPN_OVERLAP(pCbox,y,x,w) BOX_OVERLAP((pCbox),(x),(y),(x)+(w),(y)) + +#define LINE_SORT(x1,y1,x2,y2) \ +{ int _t; \ + if (x1 > x2) { _t = x1; x1 = x2; x2 = _t; } \ + if (y1 > y2) { _t = y1; y1 = y2; y2 = _t; } } + +#define LINE_OVERLAP(pCbox,x1,y1,x2,y2,lw2) \ + BOX_OVERLAP((pCbox), (x1)-(lw2), (y1)-(lw2), (x2)+(lw2), (y2)+(lw2)) diff -pNur xorg-server-1.4.orig/hw/vnc/stats.c xorg-server-1.4/hw/vnc/stats.c --- xorg-server-1.4.orig/hw/vnc/stats.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/stats.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,117 @@ +/* + * stats.c + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2002 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 <stdio.h> +#include <stdlib.h> +#include "rfb.h" + +static char* encNames[] = { + "raw", "copyRect", "RRE", "[encoding 3]", "CoRRE", "hextile", + "zlib", "tight", "[encoding 8]", "[encoding 9]" +}; + + +void +rfbResetStats(rfbClientPtr cl) +{ + int i; + for (i = 0; i < MAX_ENCODINGS; i++) { + cl->rfbBytesSent[i] = 0; + cl->rfbRectanglesSent[i] = 0; + } + cl->rfbLastRectMarkersSent = 0; + cl->rfbLastRectBytesSent = 0; + cl->rfbCursorShapeBytesSent = 0; + cl->rfbCursorShapeUpdatesSent = 0; + cl->rfbCursorPosBytesSent = 0; + cl->rfbCursorPosUpdatesSent = 0; + cl->rfbFramebufferUpdateMessagesSent = 0; + cl->rfbRawBytesEquivalent = 0; + cl->rfbKeyEventsRcvd = 0; + cl->rfbPointerEventsRcvd = 0; +} + +void +rfbPrintStats(rfbClientPtr cl) +{ + int i; + int totalRectanglesSent = 0; + int totalBytesSent = 0; + + rfbLog("Statistics:\n"); + + if ((cl->rfbKeyEventsRcvd != 0) || (cl->rfbPointerEventsRcvd != 0)) + rfbLog(" key events received %d, pointer events %d\n", + cl->rfbKeyEventsRcvd, cl->rfbPointerEventsRcvd); + + for (i = 0; i < MAX_ENCODINGS; i++) { + totalRectanglesSent += cl->rfbRectanglesSent[i]; + totalBytesSent += cl->rfbBytesSent[i]; + } + totalRectanglesSent += (cl->rfbCursorShapeUpdatesSent + + cl->rfbCursorPosUpdatesSent + + cl->rfbLastRectMarkersSent); + totalBytesSent += (cl->rfbCursorShapeBytesSent + + cl->rfbCursorPosBytesSent + + cl->rfbLastRectBytesSent); + + rfbLog(" framebuffer updates %d, rectangles %d, bytes %d\n", + cl->rfbFramebufferUpdateMessagesSent, totalRectanglesSent, + totalBytesSent); + + if (cl->rfbLastRectMarkersSent != 0) + rfbLog(" LastRect markers %d, bytes %d\n", + cl->rfbLastRectMarkersSent, cl->rfbLastRectBytesSent); + + if (cl->rfbCursorShapeUpdatesSent != 0) + rfbLog(" cursor shape updates %d, bytes %d\n", + cl->rfbCursorShapeUpdatesSent, cl->rfbCursorShapeBytesSent); + + if (cl->rfbCursorPosUpdatesSent != 0) + rfbLog(" cursor position updates %d, bytes %d\n", + cl->rfbCursorPosUpdatesSent, cl->rfbCursorPosBytesSent); + + for (i = 0; i < MAX_ENCODINGS; i++) { + if (cl->rfbRectanglesSent[i] != 0) + rfbLog(" %s rectangles %d, bytes %d\n", + encNames[i], cl->rfbRectanglesSent[i], cl->rfbBytesSent[i]); + } + + if ((totalBytesSent - cl->rfbBytesSent[rfbEncodingCopyRect]) != 0) { + rfbLog(" raw bytes equivalent %d, compression ratio %f\n", + cl->rfbRawBytesEquivalent, + (double)cl->rfbRawBytesEquivalent + / (double)(totalBytesSent - + cl->rfbBytesSent[rfbEncodingCopyRect] - + cl->rfbCursorShapeBytesSent - + cl->rfbCursorPosBytesSent - + cl->rfbLastRectBytesSent)); + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/symlink-vnc.sh xorg-server-1.4/hw/vnc/symlink-vnc.sh --- xorg-server-1.4.orig/hw/vnc/symlink-vnc.sh 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/symlink-vnc.sh 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,198 @@ +#!/bin/sh + +# +# A script that symlinks source files from vnc to modular +# +# Author: Soren Sandmann (sandmann@redhat.com) (original) +# adapted for vnc by Alan Hourihane <alanh@fairlite.demon.co.uk> + +# +# Things we would like to do +# +# - Check that all the relevant files exist +# - AUTHORS, autogen.sh, configure.ac, ... +# - Check that we have actually linked everything +# - if a file doesn't need to be linked, then it needs +# to be listed as "not-linked" +# - Compute diffs between all the files (shouldn't be necessary) +# - possibly check that files are listet in Makefile.am's +# - Clean target directory of irrelevant files +# + +check_destinations () { + # don't do anything - we are relying on the side + # effect of dst_dir + true +} + +check_exist() { + # Check whether $1 exists + + if [ ! -e $1 ] ; then + error "$1 not found" + fi +} + +delete_existing() { + # Delete $2 + + rm -f $2 +} + +link_files() { + # Link $1 to $2 + + if [ ! -e $2 ] ; then + ln -s $1 $2 + fi +} + +main() { + check_args $1 $2 + + run check_destinations "Creating destination directories" + run check_exist "Checking that the source files exist" + run delete_existing "Deleting existing files" + run link_files "Linking files" +} + +## actual symlinking + +symlink_vnc() { + src_dir . + dst_dir . + action d3des.c + action d3des.h + action auth.c + action cmap.c + action corre.c + action cursor.c + action cutpaste.c + action dispcur.c + action draw.c + action hextile.c + action httpd.c + action kbdptr.c + action keyboard.h + action loginauth.c + action rdp.c + action rfb.h + action rfbkeyb.c + action rfbmouse.c + action rfbproto.h + action rfbserver.c + action rre.c + action sockets.c + action sprite.c + action sprite.h + action spritest.h + action stats.c + action tableinitcmtemplate.c + action tableinittctemplate.c + action tabletranstemplate.c + action tight.c + action translate.c + action vncauth.c + action vncauth.h + action vncext.c + action xistubs.c + action zlib.c +} + +######### +# +# Helper functions +# +######### + +error() { + echo + echo \ \ \ error:\ \ \ $1 + exit 1 +} + +# printing out what's going on +run_module() { + # $1 module + # $2 explanation + echo -n $EXPLANATION for $1 module ...\ + symlink_$1 + echo DONE +} + +run() { + # $1 what to do + # $2 explanation + + ACTION=$1 EXPLANATION=$2 run_module vnc +} + +src_dir() { + REAL_SRC_DIR=$SRC_DIR/$1 + if [ ! -d $REAL_SRC_DIR ] ; then + error "Source directory $REAL_SRC_DIR does not exist" + fi +} + +dst_dir() { + REAL_DST_DIR=$DST_DIR/$1 + if [ ! -d $REAL_DST_DIR ] ; then + mkdir -p $REAL_DST_DIR + fi +} + +action() { + if [ -z $2 ] ; then + $ACTION $REAL_SRC_DIR/$1 $REAL_DST_DIR/$1 + else + $ACTION $REAL_SRC_DIR/$1 $REAL_DST_DIR/$2 + fi +} + +usage() { + echo symlink.sh src-dir dst-dir + echo src-dir: the xc directory of the monolithic source tree + echo dst-dir: the modular source tree containing proto, app, lib, ... +} + +# Check commandline args +check_args() { + if [ -z $1 ] ; then + echo Missing source dir + usage + exit 1 + fi + + if [ -z $2 ] ; then + echo Missing destination dir + usage + exit 1 + fi + + if [ ! -d $1 ] ; then + echo $1 is not a dir + usage + exit 1 + fi + + if [ ! -d $2 ] ; then + echo $2 is not a dir + usage + exit 1 + fi + + if [ $1 = $2 ] ; then + echo source and destination can\'t be the same + usage + exit 1 + fi + + D=`dirname "$relpath"` + B=`basename "$relpath"` + abspath="`cd \"$D\" 2>/dev/null && pwd || echo \"$D\"`/$B" + + SRC_DIR=`( cd $1 ; pwd )` + DST_DIR=`(cd $2 ; pwd )` +} + +main $1 $2 diff -pNur xorg-server-1.4.orig/hw/vnc/tableinitcmtemplate.c xorg-server-1.4/hw/vnc/tableinitcmtemplate.c --- xorg-server-1.4.orig/hw/vnc/tableinitcmtemplate.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/tableinitcmtemplate.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,93 @@ +/* + * tableinitcmtemplate.c - template for initialising lookup tables for + * translation from a colour map to true colour. + * + * This file shouldn't be compiled. It is included multiple times by + * translate.c, each time with a different definition of the macro OUT. + * For each value of OUT, this file defines a function which allocates an + * appropriately sized lookup table and initialises it. + * + * I know this code isn't nice to read because of all the macros, but + * efficiency is important here. + * + * 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 + + +#if !defined(OUT) +#error "This file shouldn't be compiled." +#error "It is included as part of translate.c" +#endif + +#define OUT_T CONCAT2E(CARD,OUT) +#define SwapOUT(x) CONCAT2E(Swap,OUT(x)) +#define rfbInitColourMapSingleTableOUT \ + CONCAT2E(rfbInitColourMapSingleTable,OUT) + +static void +rfbInitColourMapSingleTableOUT (ScreenPtr pScreen, char **table, rfbPixelFormat *in, + rfbPixelFormat *out) +{ + VNCSCREENPTR(pScreen); + int i, r, g, b; + OUT_T *t; + EntryPtr pent; + int nEntries = 1 << in->bitsPerPixel; + + if (*table) free(*table); + *table = (char *)malloc(nEntries * sizeof(OUT_T)); + t = (OUT_T *)*table; + +#if XFREE86VNC + pent = (EntryPtr)&miInstalledMaps[pScreen->myNum]->red[0]; +#else + pent = (EntryPtr)&pVNC->rfbInstalledColormap->red[0]; +#endif + + for (i = 0; i < nEntries; i++) { + if (pent->fShared) { + r = pent->co.shco.red->color; + g = pent->co.shco.green->color; + b = pent->co.shco.blue->color; + } else { + r = pent->co.local.red; + g = pent->co.local.green; + b = pent->co.local.blue; + } + t[i] = ((((r * out->redMax + 32767) / 65535) << out->redShift) | + (((g * out->greenMax + 32767) / 65535) << out->greenShift) | + (((b * out->blueMax + 32767) / 65535) << out->blueShift)); +#if (OUT != 8) + if (out->bigEndian != in->bigEndian) { + t[i] = SwapOUT(t[i]); + } +#endif + pent++; + } +} + +#undef OUT_T +#undef SwapOUT +#undef rfbInitColourMapSingleTableOUT diff -pNur xorg-server-1.4.orig/hw/vnc/tableinittctemplate.c xorg-server-1.4/hw/vnc/tableinittctemplate.c --- xorg-server-1.4.orig/hw/vnc/tableinittctemplate.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/tableinittctemplate.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,146 @@ +/* + * tableinittctemplate.c - template for initialising lookup tables for + * truecolour to truecolour translation. + * + * This file shouldn't be compiled. It is included multiple times by + * translate.c, each time with a different definition of the macro OUT. + * For each value of OUT, this file defines two functions for initialising + * lookup tables. One is for truecolour translation using a single lookup + * table, the other is for truecolour translation using three separate + * lookup tables for the red, green and blue values. + * + * I know this code isn't nice to read because of all the macros, but + * efficiency is important here. + * + * 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 + + +#if !defined(OUT) +#error "This file shouldn't be compiled." +#error "It is included as part of translate.c" +#endif + +#define OUT_T CONCAT2E(CARD,OUT) +#define SwapOUT(x) CONCAT2E(Swap,OUT(x)) +#define rfbInitTrueColourSingleTableOUT \ + CONCAT2E(rfbInitTrueColourSingleTable,OUT) +#define rfbInitTrueColourRGBTablesOUT CONCAT2E(rfbInitTrueColourRGBTables,OUT) +#define rfbInitOneRGBTableOUT CONCAT2E(rfbInitOneRGBTable,OUT) + +static void +rfbInitOneRGBTableOUT (OUT_T *table, int inMax, int outMax, int outShift, + int swap); + + +/* + * rfbInitTrueColourSingleTable sets up a single lookup table for truecolour + * translation. + */ + +static void +rfbInitTrueColourSingleTableOUT (ScreenPtr pScreen, char **table, rfbPixelFormat *in, + rfbPixelFormat *out) +{ + int i; + int inRed, inGreen, inBlue, outRed, outGreen, outBlue; + OUT_T *t; + int nEntries = 1 << in->bitsPerPixel; + + if (*table) free(*table); + *table = (char *)malloc(nEntries * sizeof(OUT_T)); + t = (OUT_T *)*table; + + for (i = 0; i < nEntries; i++) { + inRed = (i >> in->redShift) & in->redMax; + inGreen = (i >> in->greenShift) & in->greenMax; + inBlue = (i >> in->blueShift) & in->blueMax; + + outRed = (inRed * out->redMax + in->redMax / 2) / in->redMax; + outGreen = (inGreen * out->greenMax + in->greenMax / 2) / in->greenMax; + outBlue = (inBlue * out->blueMax + in->blueMax / 2) / in->blueMax; + + t[i] = ((outRed << out->redShift) | + (outGreen << out->greenShift) | + (outBlue << out->blueShift)); +#if (OUT != 8) + if (out->bigEndian != in->bigEndian) { + t[i] = SwapOUT(t[i]); + } +#endif + } +} + + +/* + * rfbInitTrueColourRGBTables sets up three separate lookup tables for the + * red, green and blue values. + */ + +static void +rfbInitTrueColourRGBTablesOUT (ScreenPtr pScreen, char **table, rfbPixelFormat *in, + rfbPixelFormat *out) +{ + OUT_T *redTable; + OUT_T *greenTable; + OUT_T *blueTable; + + if (*table) free(*table); + *table = (char *)malloc((in->redMax + in->greenMax + in->blueMax + 3) + * sizeof(OUT_T)); + redTable = (OUT_T *)*table; + greenTable = redTable + in->redMax + 1; + blueTable = greenTable + in->greenMax + 1; + + rfbInitOneRGBTableOUT (redTable, in->redMax, out->redMax, + out->redShift, (out->bigEndian != in->bigEndian)); + rfbInitOneRGBTableOUT (greenTable, in->greenMax, out->greenMax, + out->greenShift, (out->bigEndian != in->bigEndian)); + rfbInitOneRGBTableOUT (blueTable, in->blueMax, out->blueMax, + out->blueShift, (out->bigEndian != in->bigEndian)); +} + +static void +rfbInitOneRGBTableOUT (OUT_T *table, int inMax, int outMax, int outShift, + int swap) +{ + int i; + int nEntries = inMax + 1; + + for (i = 0; i < nEntries; i++) { + table[i] = ((i * outMax + inMax / 2) / inMax) << outShift; +#if (OUT != 8) + if (swap) { + table[i] = SwapOUT(table[i]); + } +#endif + } +} + +#undef OUT_T +#undef SwapOUT +#undef rfbInitTrueColourSingleTableOUT +#undef rfbInitTrueColourRGBTablesOUT +#undef rfbInitOneRGBTableOUT diff -pNur xorg-server-1.4.orig/hw/vnc/tabletranstemplate.c xorg-server-1.4/hw/vnc/tabletranstemplate.c --- xorg-server-1.4.orig/hw/vnc/tabletranstemplate.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/tabletranstemplate.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,135 @@ +/* + * tabletranstemplate.c - template for translation using lookup tables. + * + * This file shouldn't be compiled. It is included multiple times by + * translate.c, each time with different definitions of the macros IN and OUT. + * + * For each pair of values IN and OUT, this file defines two functions for + * translating a given rectangle of pixel data. One uses a single lookup + * table, and the other uses three separate lookup tables for the red, green + * and blue values. + * + * I know this code isn't nice to read because of all the macros, but + * efficiency is important here. + * + * 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 + + +#if !defined(IN) || !defined(OUT) +#error "This file shouldn't be compiled." +#error "It is included as part of translate.c" +#endif + +#define IN_T CONCAT2E(CARD,IN) +#define OUT_T CONCAT2E(CARD,OUT) +#define rfbTranslateWithSingleTableINtoOUT \ + CONCAT4E(rfbTranslateWithSingleTable,IN,to,OUT) +#define rfbTranslateWithRGBTablesINtoOUT \ + CONCAT4E(rfbTranslateWithRGBTables,IN,to,OUT) + +/* + * rfbTranslateWithSingleTableINtoOUT translates a rectangle of pixel data + * using a single lookup table. + */ + +static void +rfbTranslateWithSingleTableINtoOUT (ScreenPtr pScreen, char *table, rfbPixelFormat *in, + rfbPixelFormat *out, + unsigned char *optr, + int bytesBetweenInputLines, + int width, int height, + int x, int y) +{ + IN_T *ip; + OUT_T *op = (OUT_T *)optr; + OUT_T *opLineEnd; + OUT_T *t = (OUT_T *)table; + DrawablePtr pDraw = (DrawablePtr)WindowTable[pScreen->myNum]; + int truewidth = PixmapBytePad(width, in->bitsPerPixel); + unsigned char *iptr = malloc(truewidth * height * in->bitsPerPixel / 8); + int ipextra = truewidth - width; + (*pScreen->GetImage)(pDraw, x, y, truewidth, height, ZPixmap, ~0, (char*)iptr); + ip = (IN_T *)iptr; + + while (height > 0) { + opLineEnd = op + width; + + while (op < opLineEnd) { + *(op++) = t[*(ip++)]; + } + + ip += ipextra; + height--; + } + free(iptr); +} + + +/* + * rfbTranslateWithRGBTablesINtoOUT translates a rectangle of pixel data + * using three separate lookup tables for the red, green and blue values. + */ + +static void +rfbTranslateWithRGBTablesINtoOUT (ScreenPtr pScreen, char *table, rfbPixelFormat *in, + rfbPixelFormat *out, + unsigned char *optr, + int bytesBetweenInputLines, + int width, int height, + int x, int y) +{ + IN_T *ip; + OUT_T *op = (OUT_T *)optr; + OUT_T *opLineEnd; + OUT_T *redTable = (OUT_T *)table; + OUT_T *greenTable = redTable + in->redMax + 1; + OUT_T *blueTable = greenTable + in->greenMax + 1; + DrawablePtr pDraw = (DrawablePtr)WindowTable[pScreen->myNum]; + int truewidth = PixmapBytePad(width, in->bitsPerPixel); + unsigned char *iptr = malloc(truewidth * height * in->bitsPerPixel / 8); + int ipextra = truewidth - width; + (*pScreen->GetImage)(pDraw, x, y, truewidth, height, ZPixmap, ~0, (char*)iptr); + ip = (IN_T *)iptr; + + while (height > 0) { + opLineEnd = op + width; + + while (op < opLineEnd) { + *(op++) = (redTable[(*ip >> in->redShift) & in->redMax] | + greenTable[(*ip >> in->greenShift) & in->greenMax] | + blueTable[(*ip >> in->blueShift) & in->blueMax]); + ip++; + } + ip += ipextra; + height--; + } + free(iptr); +} + +#undef IN_T +#undef OUT_T +#undef rfbTranslateWithSingleTableINtoOUT +#undef rfbTranslateWithRGBTablesINtoOUT diff -pNur xorg-server-1.4.orig/hw/vnc/tight.c xorg-server-1.4/hw/vnc/tight.c --- xorg-server-1.4.orig/hw/vnc/tight.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/tight.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,1827 @@ +/* + * tight.c + * + * Routines to implement Tight Encoding + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2000, 2001 Const 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 <stdio.h> +#include "rfb.h" +#include <jpeglib.h> + + +/* Note: The following constant should not be changed. */ +#define TIGHT_MIN_TO_COMPRESS 12 + +/* The parameters below may be adjusted. */ +#define MIN_SPLIT_RECT_SIZE 4096 +#define MIN_SOLID_SUBRECT_SIZE 2048 +#define MAX_SPLIT_TILE_SIZE 16 + +/* May be set to TRUE with "-lazytight" Xvnc option. */ +Bool rfbTightDisableGradient = FALSE; + +/* This variable is set on every rfbSendRectEncodingTight() call. */ +static Bool usePixelFormat24; + + +/* Compression level stuff. The following array contains various + encoder parameters for each of 10 compression levels (0..9). + Last three parameters correspond to JPEG quality levels (0..9). */ + +typedef struct TIGHT_CONF_s { + int maxRectSize, maxRectWidth; + int monoMinRectSize, gradientMinRectSize; + int idxZlibLevel, monoZlibLevel, rawZlibLevel, gradientZlibLevel; + int gradientThreshold, gradientThreshold24; + int idxMaxColorsDivisor; + int jpegQuality, jpegThreshold, jpegThreshold24; +} TIGHT_CONF; + +static TIGHT_CONF tightConf[10] = { + { 512, 32, 6, 65536, 0, 0, 0, 0, 0, 0, 4, 5, 10000, 23000 }, + { 2048, 128, 6, 65536, 1, 1, 1, 0, 0, 0, 8, 10, 8000, 18000 }, + { 6144, 256, 8, 65536, 3, 3, 2, 0, 0, 0, 24, 15, 6500, 15000 }, + { 10240, 1024, 12, 65536, 5, 5, 3, 0, 0, 0, 32, 25, 5000, 12000 }, + { 16384, 2048, 12, 65536, 6, 6, 4, 0, 0, 0, 32, 37, 4000, 10000 }, + { 32768, 2048, 12, 4096, 7, 7, 5, 4, 150, 380, 32, 50, 3000, 8000 }, + { 65536, 2048, 16, 4096, 7, 7, 6, 4, 170, 420, 48, 60, 2000, 5000 }, + { 65536, 2048, 16, 4096, 8, 8, 7, 5, 180, 450, 64, 70, 1000, 2500 }, + { 65536, 2048, 32, 8192, 9, 9, 8, 6, 190, 475, 64, 75, 500, 1200 }, + { 65536, 2048, 32, 8192, 9, 9, 9, 6, 200, 500, 96, 80, 200, 500 } +}; + +/* Stuff dealing with palettes. */ + +typedef struct COLOR_LIST_s { + struct COLOR_LIST_s *next; + int idx; + CARD32 rgb; +} COLOR_LIST; + +typedef struct PALETTE_ENTRY_s { + COLOR_LIST *listNode; + int numPixels; +} PALETTE_ENTRY; + +typedef struct PALETTE_s { + PALETTE_ENTRY entry[256]; + COLOR_LIST *hash[256]; + COLOR_LIST list[256]; +} PALETTE; + +static int paletteNumColors, paletteMaxColors; +static CARD32 monoBackground, monoForeground; +static PALETTE palette; + +/* Pointers to dynamically-allocated buffers. */ + +static int tightBeforeBufSize = 0; +static unsigned char *tightBeforeBuf = NULL; + +static int tightAfterBufSize = 0; +static unsigned char *tightAfterBuf = NULL; + +static int *prevRowBuf = NULL; + + +/* Prototypes for static functions. */ + +static void FindBestSolidArea (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 colorValue, int *w_ptr, int *h_ptr); +static void ExtendSolidArea (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 colorValue, + int *x_ptr, int *y_ptr, int *w_ptr, int *h_ptr); +static Bool CheckSolidTile (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 *colorPtr, Bool needSameColor); +static Bool CheckSolidTile8 (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 *colorPtr, Bool needSameColor); +static Bool CheckSolidTile16 (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 *colorPtr, Bool needSameColor); +static Bool CheckSolidTile32 (ScreenPtr pScreen, int x, int y, int w, int h, + CARD32 *colorPtr, Bool needSameColor); + +static Bool SendRectSimple (rfbClientPtr cl, int x, int y, int w, int h); +static Bool SendSubrect (rfbClientPtr cl, int x, int y, int w, int h); +static Bool SendTightHeader (rfbClientPtr cl, int x, int y, int w, int h); + +static Bool SendSolidRect (rfbClientPtr cl); +static Bool SendMonoRect (rfbClientPtr cl, int w, int h); +static Bool SendIndexedRect (rfbClientPtr cl, int w, int h); +static Bool SendFullColorRect (rfbClientPtr cl, int w, int h); +static Bool SendGradientRect (rfbClientPtr cl, int w, int h); + +static Bool CompressData(rfbClientPtr cl, int streamId, int dataLen, + int zlibLevel, int zlibStrategy); +static Bool SendCompressedData(rfbClientPtr cl, int compressedLen); + +static void FillPalette8(int count); +static void FillPalette16(int count); +static void FillPalette32(int count); + +static void PaletteReset(void); +static int PaletteInsert(CARD32 rgb, int numPixels, int bpp); + +static void Pack24(ScreenPtr pScreen, unsigned char *buf, rfbPixelFormat *fmt, int count); + +static void EncodeIndexedRect16(CARD8 *buf, int count); +static void EncodeIndexedRect32(CARD8 *buf, int count); + +static void EncodeMonoRect8(CARD8 *buf, int w, int h); +static void EncodeMonoRect16(CARD8 *buf, int w, int h); +static void EncodeMonoRect32(CARD8 *buf, int w, int h); + +static void FilterGradient24(ScreenPtr pScreen, unsigned char *buf, rfbPixelFormat *fmt, int w, int h); +static void FilterGradient16(ScreenPtr pScreen, CARD16 *buf, rfbPixelFormat *fmt, int w, int h); +static void FilterGradient32(ScreenPtr pScreen, CARD32 *buf, rfbPixelFormat *fmt, int w, int h); + +static int DetectSmoothImage(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h); +static unsigned long DetectSmoothImage24(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h); +static unsigned long DetectSmoothImage16(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h); +static unsigned long DetectSmoothImage32(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h); + +static Bool SendJpegRect(rfbClientPtr cl, const CARD8 *buffer, int w, int h, int quality); +static void PrepareRowForJpeg(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, int row, int width); +static void PrepareRowForJpeg24(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, int row, int width); +static void PrepareRowForJpeg16(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, int row, int width); +static void PrepareRowForJpeg32(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, int row, int width); + +static void JpegInitDestination(j_compress_ptr cinfo); +static boolean JpegEmptyOutputBuffer(j_compress_ptr cinfo); +static void JpegTermDestination(j_compress_ptr cinfo); +static void JpegSetDstManager(j_compress_ptr cinfo); + + +/* + * Tight encoding implementation. + */ + +int +rfbNumCodedRectsTight(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + int maxRectSize, maxRectWidth; + int subrectMaxWidth, subrectMaxHeight; + + /* No matter how many rectangles we will send if LastRect markers + are used to terminate rectangle stream. */ + if (cl->enableLastRectEncoding && w * h >= MIN_SPLIT_RECT_SIZE) + return 0; + + maxRectSize = tightConf[cl->tightCompressLevel].maxRectSize; + maxRectWidth = tightConf[cl->tightCompressLevel].maxRectWidth; + + if (w > maxRectWidth || w * h > maxRectSize) { + subrectMaxWidth = (w > maxRectWidth) ? maxRectWidth : w; + subrectMaxHeight = maxRectSize / subrectMaxWidth; + return (((w - 1) / maxRectWidth + 1) * + ((h - 1) / subrectMaxHeight + 1)); + } else { + return 1; + } +} + +Bool +rfbSendRectEncodingTight(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + int nMaxRows; + CARD32 colorValue; + int dx, dy, dw, dh; + int x_best, y_best, w_best, h_best; + + if ( cl->format.depth == 24 && cl->format.redMax == 0xFF && + cl->format.greenMax == 0xFF && cl->format.blueMax == 0xFF ) { + usePixelFormat24 = TRUE; + } else { + usePixelFormat24 = FALSE; + } + + if (!cl->enableLastRectEncoding || w * h < MIN_SPLIT_RECT_SIZE) + return SendRectSimple(cl, x, y, w, h); + + /* Make sure we can write at least one pixel into tightBeforeBuf. */ + + if (tightBeforeBufSize < 4) { + tightBeforeBufSize = 4; + if (tightBeforeBuf == NULL) + tightBeforeBuf = (unsigned char *)xalloc(tightBeforeBufSize); + else + tightBeforeBuf = (unsigned char *)xrealloc(tightBeforeBuf, + tightBeforeBufSize); + } + + /* Calculate maximum number of rows in one non-solid rectangle. */ + + { + int maxRectSize, maxRectWidth, nMaxWidth; + + maxRectSize = tightConf[cl->tightCompressLevel].maxRectSize; + maxRectWidth = tightConf[cl->tightCompressLevel].maxRectWidth; + nMaxWidth = (w > maxRectWidth) ? maxRectWidth : w; + nMaxRows = maxRectSize / nMaxWidth; + } + + /* Try to find large solid-color areas and send them separately. */ + + for (dy = y; dy < y + h; dy += MAX_SPLIT_TILE_SIZE) { + + /* If a rectangle becomes too large, send its upper part now. */ + + if (dy - y >= nMaxRows) { + if (!SendRectSimple(cl, x, y, w, nMaxRows)) + return 0; + y += nMaxRows; + h -= nMaxRows; + } + + dh = (dy + MAX_SPLIT_TILE_SIZE <= y + h) ? + MAX_SPLIT_TILE_SIZE : (y + h - dy); + + for (dx = x; dx < x + w; dx += MAX_SPLIT_TILE_SIZE) { + + dw = (dx + MAX_SPLIT_TILE_SIZE <= x + w) ? + MAX_SPLIT_TILE_SIZE : (x + w - dx); + + if (CheckSolidTile(cl->pScreen, dx, dy, dw, dh, &colorValue, FALSE)) { + + /* Get dimensions of solid-color area. */ + + FindBestSolidArea(cl->pScreen, dx, dy, w - (dx - x), h - (dy - y), + colorValue, &w_best, &h_best); + + /* Make sure a solid rectangle is large enough + (or the whole rectangle is of the same color). */ + + if ( w_best * h_best != w * h && + w_best * h_best < MIN_SOLID_SUBRECT_SIZE ) + continue; + + /* Try to extend solid rectangle to maximum size. */ + + x_best = dx; y_best = dy; + ExtendSolidArea(cl->pScreen, x, y, w, h, colorValue, + &x_best, &y_best, &w_best, &h_best); + + /* Send rectangles at top and left to solid-color area. */ + + if ( y_best != y && + !SendRectSimple(cl, x, y, w, y_best-y) ) + return FALSE; + if ( x_best != x && + !rfbSendRectEncodingTight(cl, x, y_best, + x_best-x, h_best) ) + return FALSE; + + /* Send solid-color rectangle. */ + + if (!SendTightHeader(cl, x_best, y_best, w_best, h_best)) + return FALSE; + + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, + &pVNC->rfbServerFormat, + &cl->format, tightBeforeBuf, + pVNC->paddedWidthInBytes, 1, 1, + x_best, y_best); + + if (!SendSolidRect(cl)) + return FALSE; + + /* Send remaining rectangles (at right and bottom). */ + + if ( x_best + w_best != x + w && + !rfbSendRectEncodingTight(cl, x_best+w_best, y_best, + w-(x_best-x)-w_best, h_best) ) + return FALSE; + if ( y_best + h_best != y + h && + !rfbSendRectEncodingTight(cl, x, y_best+h_best, + w, h-(y_best-y)-h_best) ) + return FALSE; + + /* Return after all recursive calls are done. */ + + return TRUE; + } + + } + + } + + /* No suitable solid-color rectangles found. */ + + return SendRectSimple(cl, x, y, w, h); +} + +static void +FindBestSolidArea(pScreen, x, y, w, h, colorValue, w_ptr, h_ptr) + ScreenPtr pScreen; + int x, y, w, h; + CARD32 colorValue; + int *w_ptr, *h_ptr; +{ + int dx, dy, dw, dh; + int w_prev; + int w_best = 0, h_best = 0; + + w_prev = w; + + for (dy = y; dy < y + h; dy += MAX_SPLIT_TILE_SIZE) { + + dh = (dy + MAX_SPLIT_TILE_SIZE <= y + h) ? + MAX_SPLIT_TILE_SIZE : (y + h - dy); + dw = (w_prev > MAX_SPLIT_TILE_SIZE) ? + MAX_SPLIT_TILE_SIZE : w_prev; + + if (!CheckSolidTile(pScreen, x, dy, dw, dh, &colorValue, TRUE)) + break; + + for (dx = x + dw; dx < x + w_prev;) { + dw = (dx + MAX_SPLIT_TILE_SIZE <= x + w_prev) ? + MAX_SPLIT_TILE_SIZE : (x + w_prev - dx); + if (!CheckSolidTile(pScreen, dx, dy, dw, dh, &colorValue, TRUE)) + break; + dx += dw; + } + + w_prev = dx - x; + if (w_prev * (dy + dh - y) > w_best * h_best) { + w_best = w_prev; + h_best = dy + dh - y; + } + } + + *w_ptr = w_best; + *h_ptr = h_best; +} + +static void +ExtendSolidArea(pScreen, x, y, w, h, colorValue, x_ptr, y_ptr, w_ptr, h_ptr) + ScreenPtr pScreen; + int x, y, w, h; + CARD32 colorValue; + int *x_ptr, *y_ptr, *w_ptr, *h_ptr; +{ + int cx, cy; + + /* Try to extend the area upwards. */ + for ( cy = *y_ptr - 1; + cy >= y && CheckSolidTile(pScreen, *x_ptr, cy, *w_ptr, 1, &colorValue, TRUE); + cy-- ); + *h_ptr += *y_ptr - (cy + 1); + *y_ptr = cy + 1; + + /* ... downwards. */ + for ( cy = *y_ptr + *h_ptr; + cy < y + h && + CheckSolidTile(pScreen, *x_ptr, cy, *w_ptr, 1, &colorValue, TRUE); + cy++ ); + *h_ptr += cy - (*y_ptr + *h_ptr); + + /* ... to the left. */ + for ( cx = *x_ptr - 1; + cx >= x && CheckSolidTile(pScreen, cx, *y_ptr, 1, *h_ptr, &colorValue, TRUE); + cx-- ); + *w_ptr += *x_ptr - (cx + 1); + *x_ptr = cx + 1; + + /* ... to the right. */ + for ( cx = *x_ptr + *w_ptr; + cx < x + w && + CheckSolidTile(pScreen, cx, *y_ptr, 1, *h_ptr, &colorValue, TRUE); + cx++ ); + *w_ptr += cx - (*x_ptr + *w_ptr); +} + +/* + * Check if a rectangle is all of the same color. If needSameColor is + * set to non-zero, then also check that its color equals to the + * *colorPtr value. The result is 1 if the test is successfull, and in + * that case new color will be stored in *colorPtr. + */ + +static Bool +CheckSolidTile(pScreen, x, y, w, h, colorPtr, needSameColor) + ScreenPtr pScreen; + int x, y, w, h; + CARD32 *colorPtr; + Bool needSameColor; +{ + VNCSCREENPTR(pScreen); + switch(pVNC->rfbServerFormat.bitsPerPixel) { + case 32: + return CheckSolidTile32(pScreen, x, y, w, h, colorPtr, needSameColor); + case 16: + return CheckSolidTile16(pScreen, x, y, w, h, colorPtr, needSameColor); + default: + return CheckSolidTile8(pScreen, x, y, w, h, colorPtr, needSameColor); + } +} + +#define DEFINE_CHECK_SOLID_FUNCTION(bpp) \ + \ +static Bool \ +CheckSolidTile##bpp(pScreen, x, y, w, h, colorPtr, needSameColor) \ + ScreenPtr pScreen; \ + int x, y; \ + CARD32 *colorPtr; \ + Bool needSameColor; \ +{ \ + VNCSCREENPTR(pScreen); \ + CARD##bpp *fbptr; \ + CARD##bpp colorValue; \ + int dx, dy; \ + \ + fbptr = (CARD##bpp *) \ + &pVNC->pfbMemory[y * pVNC->paddedWidthInBytes + x * (bpp/8)]; \ + \ + colorValue = *fbptr; \ + if (needSameColor && (CARD32)colorValue != *colorPtr) \ + return FALSE; \ + \ + for (dy = 0; dy < h; dy++) { \ + for (dx = 0; dx < w; dx++) { \ + if (colorValue != fbptr[dx]) \ + return FALSE; \ + } \ + fbptr = (CARD##bpp *)((CARD8 *)fbptr + pVNC->paddedWidthInBytes); \ + } \ + \ + *colorPtr = (CARD32)colorValue; \ + return TRUE; \ +} + +DEFINE_CHECK_SOLID_FUNCTION(8) +DEFINE_CHECK_SOLID_FUNCTION(16) +DEFINE_CHECK_SOLID_FUNCTION(32) + +static Bool +SendRectSimple(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + int maxBeforeSize, maxAfterSize; + int maxRectSize, maxRectWidth; + int subrectMaxWidth, subrectMaxHeight; + int dx, dy; + int rw, rh; + + maxRectSize = tightConf[cl->tightCompressLevel].maxRectSize; + maxRectWidth = tightConf[cl->tightCompressLevel].maxRectWidth; + + maxBeforeSize = maxRectSize * (cl->format.bitsPerPixel / 8); + maxAfterSize = maxBeforeSize + (maxBeforeSize + 99) / 100 + 12; + + if (tightBeforeBufSize < maxBeforeSize) { + tightBeforeBufSize = maxBeforeSize; + if (tightBeforeBuf == NULL) + tightBeforeBuf = (unsigned char *)xalloc(tightBeforeBufSize); + else + tightBeforeBuf = (unsigned char *)xrealloc(tightBeforeBuf, + tightBeforeBufSize); + } + + if (tightAfterBufSize < maxAfterSize) { + tightAfterBufSize = maxAfterSize; + if (tightAfterBuf == NULL) + tightAfterBuf = (unsigned char *)xalloc(tightAfterBufSize); + else + tightAfterBuf = (unsigned char *)xrealloc(tightAfterBuf, + tightAfterBufSize); + } + + if (w > maxRectWidth || w * h > maxRectSize) { + subrectMaxWidth = (w > maxRectWidth) ? maxRectWidth : w; + subrectMaxHeight = maxRectSize / subrectMaxWidth; + + for (dy = 0; dy < h; dy += subrectMaxHeight) { + for (dx = 0; dx < w; dx += maxRectWidth) { + rw = (dx + maxRectWidth < w) ? maxRectWidth : w - dx; + rh = (dy + subrectMaxHeight < h) ? subrectMaxHeight : h - dy; + if (!SendSubrect(cl, x+dx, y+dy, rw, rh)) + return FALSE; + } + } + } else { + if (!SendSubrect(cl, x, y, w, h)) + return FALSE; + } + + return TRUE; +} + +static Bool +SendSubrect(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + Bool success = FALSE; + + /* Send pending data if there is more than 128 bytes. */ + if (pVNC->ublen > 128) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + if (!SendTightHeader(cl, x, y, w, h)) + return FALSE; + + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, &pVNC->rfbServerFormat, + &cl->format, tightBeforeBuf, + pVNC->paddedWidthInBytes, w, h, x, y); + + paletteMaxColors = w * h / tightConf[cl->tightCompressLevel].idxMaxColorsDivisor; + if ( paletteMaxColors < 2 && + w * h >= tightConf[cl->tightCompressLevel].monoMinRectSize ) { + paletteMaxColors = 2; + } + switch (cl->format.bitsPerPixel) { + case 8: + FillPalette8(w * h); + break; + case 16: + FillPalette16(w * h); + break; + default: + FillPalette32(w * h); + } + + switch (paletteNumColors) { + case 0: + /* Truecolor image */ + if (DetectSmoothImage(cl, &cl->format, w, h)) { + if (cl->tightQualityLevel != -1) { + success = SendJpegRect(cl, tightBeforeBuf, w, h, + tightConf[cl->tightQualityLevel].jpegQuality); + } else { + success = SendGradientRect(cl, w, h); + } + } else { + success = SendFullColorRect(cl, w, h); + } + break; + case 1: + /* Solid rectangle */ + success = SendSolidRect(cl); + break; + case 2: + /* Two-color rectangle */ + success = SendMonoRect(cl, w, h); + break; + default: + /* Up to 256 different colors */ + if ( paletteNumColors > 96 && + cl->tightQualityLevel != -1 && cl->tightQualityLevel <= 3 && + DetectSmoothImage(cl, &cl->format, w, h) ) { + success = SendJpegRect(cl, tightBeforeBuf, w, h, + tightConf[cl->tightQualityLevel].jpegQuality); + } else { + success = SendIndexedRect(cl, w, h); + } + } + return success; +} + +static Bool +SendTightHeader(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + rfbFramebufferUpdateRectHeader rect; + + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + rect.r.x = Swap16IfLE(x); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingTight); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + cl->rfbRectanglesSent[rfbEncodingTight]++; + cl->rfbBytesSent[rfbEncodingTight] += sz_rfbFramebufferUpdateRectHeader; + + return TRUE; +} + +/* + * Subencoding implementations. + */ + +static Bool +SendSolidRect(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + int len; + + if (usePixelFormat24) { + Pack24(cl->pScreen, tightBeforeBuf, &cl->format, 1); + len = 3; + } else + len = cl->format.bitsPerPixel / 8; + + if (pVNC->ublen + 1 + len > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + pVNC->updateBuf[pVNC->ublen++] = (char)(rfbTightFill << 4); + memcpy (&pVNC->updateBuf[pVNC->ublen], tightBeforeBuf, len); + pVNC->ublen += len; + + cl->rfbBytesSent[rfbEncodingTight] += len + 1; + + return TRUE; +} + +static Bool +SendMonoRect(cl, w, h) + rfbClientPtr cl; + int w, h; +{ + VNCSCREENPTR(cl->pScreen); + int streamId = 1; + int paletteLen, dataLen; + + if ( (pVNC->ublen + TIGHT_MIN_TO_COMPRESS + 6 + + 2 * cl->format.bitsPerPixel / 8) > UPDATE_BUF_SIZE ) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + /* Prepare tight encoding header. */ + dataLen = (w + 7) / 8; + dataLen *= h; + + pVNC->updateBuf[pVNC->ublen++] = (streamId | rfbTightExplicitFilter) << 4; + pVNC->updateBuf[pVNC->ublen++] = rfbTightFilterPalette; + pVNC->updateBuf[pVNC->ublen++] = 1; + + /* Prepare palette, convert image. */ + switch (cl->format.bitsPerPixel) { + + case 32: + EncodeMonoRect32((CARD8 *)tightBeforeBuf, w, h); + + ((CARD32 *)tightAfterBuf)[0] = monoBackground; + ((CARD32 *)tightAfterBuf)[1] = monoForeground; + if (usePixelFormat24) { + Pack24(cl->pScreen, tightAfterBuf, &cl->format, 2); + paletteLen = 6; + } else + paletteLen = 8; + + memcpy(&pVNC->updateBuf[pVNC->ublen], tightAfterBuf, paletteLen); + pVNC->ublen += paletteLen; + cl->rfbBytesSent[rfbEncodingTight] += 3 + paletteLen; + break; + + case 16: + EncodeMonoRect16((CARD8 *)tightBeforeBuf, w, h); + + ((CARD16 *)tightAfterBuf)[0] = (CARD16)monoBackground; + ((CARD16 *)tightAfterBuf)[1] = (CARD16)monoForeground; + + memcpy(&pVNC->updateBuf[pVNC->ublen], tightAfterBuf, 4); + pVNC->ublen += 4; + cl->rfbBytesSent[rfbEncodingTight] += 7; + break; + + default: + EncodeMonoRect8((CARD8 *)tightBeforeBuf, w, h); + + pVNC->updateBuf[pVNC->ublen++] = (char)monoBackground; + pVNC->updateBuf[pVNC->ublen++] = (char)monoForeground; + cl->rfbBytesSent[rfbEncodingTight] += 5; + } + + return CompressData(cl, streamId, dataLen, + tightConf[cl->tightCompressLevel].monoZlibLevel, + Z_DEFAULT_STRATEGY); +} + +static Bool +SendIndexedRect(cl, w, h) + rfbClientPtr cl; + int w, h; +{ + VNCSCREENPTR(cl->pScreen); + int streamId = 2; + int i, entryLen; + + if ( (pVNC->ublen + TIGHT_MIN_TO_COMPRESS + 6 + + paletteNumColors * cl->format.bitsPerPixel / 8) > UPDATE_BUF_SIZE ) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + /* Prepare tight encoding header. */ + pVNC->updateBuf[pVNC->ublen++] = (streamId | rfbTightExplicitFilter) << 4; + pVNC->updateBuf[pVNC->ublen++] = rfbTightFilterPalette; + pVNC->updateBuf[pVNC->ublen++] = (char)(paletteNumColors - 1); + + /* Prepare palette, convert image. */ + switch (cl->format.bitsPerPixel) { + + case 32: + EncodeIndexedRect32((CARD8 *)tightBeforeBuf, w * h); + + for (i = 0; i < paletteNumColors; i++) { + ((CARD32 *)tightAfterBuf)[i] = + palette.entry[i].listNode->rgb; + } + if (usePixelFormat24) { + Pack24(cl->pScreen, tightAfterBuf, &cl->format, paletteNumColors); + entryLen = 3; + } else + entryLen = 4; + + memcpy(&pVNC->updateBuf[pVNC->ublen], tightAfterBuf, paletteNumColors * entryLen); + pVNC->ublen += paletteNumColors * entryLen; + cl->rfbBytesSent[rfbEncodingTight] += 3 + paletteNumColors * entryLen; + break; + + case 16: + EncodeIndexedRect16((CARD8 *)tightBeforeBuf, w * h); + + for (i = 0; i < paletteNumColors; i++) { + ((CARD16 *)tightAfterBuf)[i] = + (CARD16)palette.entry[i].listNode->rgb; + } + + memcpy(&pVNC->updateBuf[pVNC->ublen], tightAfterBuf, paletteNumColors * 2); + pVNC->ublen += paletteNumColors * 2; + cl->rfbBytesSent[rfbEncodingTight] += 3 + paletteNumColors * 2; + break; + + default: + return FALSE; /* Should never happen. */ + } + + return CompressData(cl, streamId, w * h, + tightConf[cl->tightCompressLevel].idxZlibLevel, + Z_DEFAULT_STRATEGY); +} + +static Bool +SendFullColorRect(cl, w, h) + rfbClientPtr cl; + int w, h; +{ + VNCSCREENPTR(cl->pScreen); + int streamId = 0; + int len; + + if (pVNC->ublen + TIGHT_MIN_TO_COMPRESS + 1 > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + pVNC->updateBuf[pVNC->ublen++] = 0x00; /* stream id = 0, no flushing, no filter */ + cl->rfbBytesSent[rfbEncodingTight]++; + + if (usePixelFormat24) { + Pack24(cl->pScreen, tightBeforeBuf, &cl->format, w * h); + len = 3; + } else + len = cl->format.bitsPerPixel / 8; + + return CompressData(cl, streamId, w * h * len, + tightConf[cl->tightCompressLevel].rawZlibLevel, + Z_DEFAULT_STRATEGY); +} + +static Bool +SendGradientRect(cl, w, h) + rfbClientPtr cl; + int w, h; +{ + VNCSCREENPTR(cl->pScreen); + int streamId = 3; + int len; + + if (cl->format.bitsPerPixel == 8) + return SendFullColorRect(cl, w, h); + + if (pVNC->ublen + TIGHT_MIN_TO_COMPRESS + 2 > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + if (prevRowBuf == NULL) + prevRowBuf = (int *)xalloc(2048 * 3 * sizeof(int)); + + pVNC->updateBuf[pVNC->ublen++] = (streamId | rfbTightExplicitFilter) << 4; + pVNC->updateBuf[pVNC->ublen++] = rfbTightFilterGradient; + cl->rfbBytesSent[rfbEncodingTight] += 2; + + if (usePixelFormat24) { + FilterGradient24(cl->pScreen, tightBeforeBuf, &cl->format, w, h); + len = 3; + } else if (cl->format.bitsPerPixel == 32) { + FilterGradient32(cl->pScreen, (CARD32 *)tightBeforeBuf, &cl->format, w, h); + len = 4; + } else { + FilterGradient16(cl->pScreen, (CARD16 *)tightBeforeBuf, &cl->format, w, h); + len = 2; + } + + return CompressData(cl, streamId, w * h * len, + tightConf[cl->tightCompressLevel].gradientZlibLevel, + Z_FILTERED); +} + +/** + * Compress the data in the tightBeforeBuf buffer. + * \param dataLen - amount of data in tightBeforeBuf to compress, in bytes + */ +static Bool +CompressData(cl, streamId, dataLen, zlibLevel, zlibStrategy) + rfbClientPtr cl; + int streamId, dataLen, zlibLevel, zlibStrategy; +{ + VNCSCREENPTR(cl->pScreen); + z_streamp pz; + int err; + + if (dataLen < TIGHT_MIN_TO_COMPRESS) { + memcpy(&pVNC->updateBuf[pVNC->ublen], tightBeforeBuf, dataLen); + pVNC->ublen += dataLen; + cl->rfbBytesSent[rfbEncodingTight] += dataLen; + return TRUE; + } + + pz = &cl->zsStruct[streamId]; + + /* Initialize compression stream if needed. */ + if (!cl->zsActive[streamId]) { + pz->zalloc = Z_NULL; + pz->zfree = Z_NULL; + pz->opaque = Z_NULL; + + err = deflateInit2 (pz, zlibLevel, Z_DEFLATED, MAX_WBITS, + MAX_MEM_LEVEL, zlibStrategy); + if (err != Z_OK) + return FALSE; + + cl->zsActive[streamId] = TRUE; + cl->zsLevel[streamId] = zlibLevel; + } + + /* Prepare buffer pointers. */ + pz->next_in = (Bytef *)tightBeforeBuf; + pz->avail_in = dataLen; + pz->next_out = (Bytef *)tightAfterBuf; + pz->avail_out = tightAfterBufSize; + + /* Change compression parameters if needed. */ + if (zlibLevel != cl->zsLevel[streamId]) { + if (deflateParams (pz, zlibLevel, zlibStrategy) != Z_OK) { + return FALSE; + } + cl->zsLevel[streamId] = zlibLevel; + } + + /* Actual compression. */ + if ( deflate (pz, Z_SYNC_FLUSH) != Z_OK || + pz->avail_in != 0 || pz->avail_out == 0 ) { + return FALSE; + } + + return SendCompressedData(cl, tightAfterBufSize - pz->avail_out); +} + +static Bool SendCompressedData(cl, compressedLen) + rfbClientPtr cl; + int compressedLen; +{ + VNCSCREENPTR(cl->pScreen); + int i, portionLen; + + pVNC->updateBuf[pVNC->ublen++] = compressedLen & 0x7F; + cl->rfbBytesSent[rfbEncodingTight]++; + if (compressedLen > 0x7F) { + pVNC->updateBuf[pVNC->ublen-1] |= 0x80; + pVNC->updateBuf[pVNC->ublen++] = compressedLen >> 7 & 0x7F; + cl->rfbBytesSent[rfbEncodingTight]++; + if (compressedLen > 0x3FFF) { + pVNC->updateBuf[pVNC->ublen-1] |= 0x80; + pVNC->updateBuf[pVNC->ublen++] = compressedLen >> 14 & 0xFF; + cl->rfbBytesSent[rfbEncodingTight]++; + } + } + + portionLen = UPDATE_BUF_SIZE; + for (i = 0; i < compressedLen; i += portionLen) { + if (i + portionLen > compressedLen) { + portionLen = compressedLen - i; + } + if (pVNC->ublen + portionLen > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + memcpy(&pVNC->updateBuf[pVNC->ublen], &tightAfterBuf[i], portionLen); + pVNC->ublen += portionLen; + } + cl->rfbBytesSent[rfbEncodingTight] += compressedLen; + return TRUE; +} + +/* + * Code to determine how many different colors used in rectangle. + */ + +static void +FillPalette8(count) + int count; +{ + CARD8 *data = (CARD8 *)tightBeforeBuf; + CARD8 c0, c1; + int i, n0, n1; + + paletteNumColors = 0; + + c0 = data[0]; + for (i = 1; i < count && data[i] == c0; i++); + if (i == count) { + paletteNumColors = 1; + return; /* Solid rectangle */ + } + + if (paletteMaxColors < 2) + return; + + n0 = i; + c1 = data[i]; + n1 = 0; + for (i++; i < count; i++) { + if (data[i] == c0) { + n0++; + } else if (data[i] == c1) { + n1++; + } else + break; + } + if (i == count) { + if (n0 > n1) { + monoBackground = (CARD32)c0; + monoForeground = (CARD32)c1; + } else { + monoBackground = (CARD32)c1; + monoForeground = (CARD32)c0; + } + paletteNumColors = 2; /* Two colors */ + } +} + +#define DEFINE_FILL_PALETTE_FUNCTION(bpp) \ + \ +static void \ +FillPalette##bpp(count) \ + int count; \ +{ \ + CARD##bpp *data = (CARD##bpp *)tightBeforeBuf; \ + CARD##bpp c0, c1, ci = 0; \ + int i, n0, n1, ni; \ + \ + c0 = data[0]; \ + for (i = 1; i < count && data[i] == c0; i++); \ + if (i >= count) { \ + paletteNumColors = 1; /* Solid rectangle */ \ + return; \ + } \ + \ + if (paletteMaxColors < 2) { \ + paletteNumColors = 0; /* Full-color encoding preferred */ \ + return; \ + } \ + \ + n0 = i; \ + c1 = data[i]; \ + n1 = 0; \ + for (i++; i < count; i++) { \ + ci = data[i]; \ + if (ci == c0) { \ + n0++; \ + } else if (ci == c1) { \ + n1++; \ + } else \ + break; \ + } \ + if (i >= count) { \ + if (n0 > n1) { \ + monoBackground = (CARD32)c0; \ + monoForeground = (CARD32)c1; \ + } else { \ + monoBackground = (CARD32)c1; \ + monoForeground = (CARD32)c0; \ + } \ + paletteNumColors = 2; /* Two colors */ \ + return; \ + } \ + \ + PaletteReset(); \ + PaletteInsert (c0, (CARD32)n0, bpp); \ + PaletteInsert (c1, (CARD32)n1, bpp); \ + \ + ni = 1; \ + for (i++; i < count; i++) { \ + if (data[i] == ci) { \ + ni++; \ + } else { \ + if (!PaletteInsert (ci, (CARD32)ni, bpp)) \ + return; \ + ci = data[i]; \ + ni = 1; \ + } \ + } \ + PaletteInsert (ci, (CARD32)ni, bpp); \ +} + +DEFINE_FILL_PALETTE_FUNCTION(16) +DEFINE_FILL_PALETTE_FUNCTION(32) + + +/* + * Functions to operate with palette structures. + */ + +#define HASH_FUNC16(rgb) ((int)((((rgb) >> 8) + (rgb)) & 0xFF)) +#define HASH_FUNC32(rgb) ((int)((((rgb) >> 16) + ((rgb) >> 8)) & 0xFF)) + +static void +PaletteReset(void) +{ + paletteNumColors = 0; + memset(palette.hash, 0, 256 * sizeof(COLOR_LIST *)); +} + +static int +PaletteInsert(CARD32 rgb, int numPixels, int bpp) +{ + COLOR_LIST *pnode; + COLOR_LIST *prev_pnode = NULL; + int hash_key, idx, new_idx, count; + + hash_key = (bpp == 16) ? HASH_FUNC16(rgb) : HASH_FUNC32(rgb); + + pnode = palette.hash[hash_key]; + + while (pnode != NULL) { + if (pnode->rgb == rgb) { + /* Such palette entry already exists. */ + new_idx = idx = pnode->idx; + count = palette.entry[idx].numPixels + numPixels; + if (new_idx && palette.entry[new_idx-1].numPixels < count) { + do { + palette.entry[new_idx] = palette.entry[new_idx-1]; + palette.entry[new_idx].listNode->idx = new_idx; + new_idx--; + } + while (new_idx && palette.entry[new_idx-1].numPixels < count); + palette.entry[new_idx].listNode = pnode; + pnode->idx = new_idx; + } + palette.entry[new_idx].numPixels = count; + return paletteNumColors; + } + prev_pnode = pnode; + pnode = pnode->next; + } + + /* Check if palette is full. */ + if (paletteNumColors == 256 || paletteNumColors == paletteMaxColors) { + paletteNumColors = 0; + return 0; + } + + /* Move palette entries with lesser pixel counts. */ + for ( idx = paletteNumColors; + idx > 0 && palette.entry[idx-1].numPixels < numPixels; + idx-- ) { + palette.entry[idx] = palette.entry[idx-1]; + palette.entry[idx].listNode->idx = idx; + } + + /* Add new palette entry into the freed slot. */ + pnode = &palette.list[paletteNumColors]; + if (prev_pnode != NULL) { + prev_pnode->next = pnode; + } else { + palette.hash[hash_key] = pnode; + } + pnode->next = NULL; + pnode->idx = idx; + pnode->rgb = rgb; + palette.entry[idx].listNode = pnode; + palette.entry[idx].numPixels = numPixels; + + return (++paletteNumColors); +} + + +/* + * Converting 32-bit color samples into 24-bit colors. + * Should be called only when redMax, greenMax and blueMax are 255. + * Color components assumed to be byte-aligned. + */ + +static void Pack24(pScreen, buf, fmt, count) + ScreenPtr pScreen; + unsigned char *buf; + rfbPixelFormat *fmt; + int count; +{ + VNCSCREENPTR(pScreen); + CARD32 *buf32; + CARD32 pix; + int r_shift, g_shift, b_shift; + + buf32 = (CARD32 *)buf; + + if (!pVNC->rfbServerFormat.bigEndian == !fmt->bigEndian) { + r_shift = fmt->redShift; + g_shift = fmt->greenShift; + b_shift = fmt->blueShift; + } else { + r_shift = 24 - fmt->redShift; + g_shift = 24 - fmt->greenShift; + b_shift = 24 - fmt->blueShift; + } + + while (count--) { + pix = *buf32++; + *buf++ = (char)(pix >> r_shift); + *buf++ = (char)(pix >> g_shift); + *buf++ = (char)(pix >> b_shift); + } +} + + +/* + * Converting truecolor samples into palette indices. + */ + +#define DEFINE_IDX_ENCODE_FUNCTION(bpp) \ + \ +static void \ +EncodeIndexedRect##bpp(buf, count) \ + CARD8 *buf; \ + int count; \ +{ \ + COLOR_LIST *pnode; \ + CARD##bpp *src; \ + CARD##bpp rgb; \ + int rep = 0; \ + \ + src = (CARD##bpp *) buf; \ + \ + while (count--) { \ + rgb = *src++; \ + while (count && *src == rgb) { \ + rep++, src++, count--; \ + } \ + pnode = palette.hash[HASH_FUNC##bpp(rgb)]; \ + while (pnode != NULL) { \ + if ((CARD##bpp)pnode->rgb == rgb) { \ + *buf++ = (CARD8)pnode->idx; \ + while (rep) { \ + *buf++ = (CARD8)pnode->idx; \ + rep--; \ + } \ + break; \ + } \ + pnode = pnode->next; \ + } \ + } \ +} + +DEFINE_IDX_ENCODE_FUNCTION(16) +DEFINE_IDX_ENCODE_FUNCTION(32) + +#define DEFINE_MONO_ENCODE_FUNCTION(bpp) \ + \ +static void \ +EncodeMonoRect##bpp(buf, w, h) \ + CARD8 *buf; \ + int w, h; \ +{ \ + CARD##bpp *ptr; \ + CARD##bpp bg; \ + unsigned int value, mask; \ + int aligned_width; \ + int x, y, bg_bits; \ + \ + ptr = (CARD##bpp *) buf; \ + bg = (CARD##bpp) monoBackground; \ + aligned_width = w - w % 8; \ + \ + for (y = 0; y < h; y++) { \ + for (x = 0; x < aligned_width; x += 8) { \ + for (bg_bits = 0; bg_bits < 8; bg_bits++) { \ + if (*ptr++ != bg) \ + break; \ + } \ + if (bg_bits == 8) { \ + *buf++ = 0; \ + continue; \ + } \ + mask = 0x80 >> bg_bits; \ + value = mask; \ + for (bg_bits++; bg_bits < 8; bg_bits++) { \ + mask >>= 1; \ + if (*ptr++ != bg) { \ + value |= mask; \ + } \ + } \ + *buf++ = (CARD8)value; \ + } \ + \ + mask = 0x80; \ + value = 0; \ + if (x >= w) \ + continue; \ + \ + for (; x < w; x++) { \ + if (*ptr++ != bg) { \ + value |= mask; \ + } \ + mask >>= 1; \ + } \ + *buf++ = (CARD8)value; \ + } \ +} + +DEFINE_MONO_ENCODE_FUNCTION(8) +DEFINE_MONO_ENCODE_FUNCTION(16) +DEFINE_MONO_ENCODE_FUNCTION(32) + + +/* + * ``Gradient'' filter for 24-bit color samples. + * Should be called only when redMax, greenMax and blueMax are 255. + * Color components assumed to be byte-aligned. + */ + +static void +FilterGradient24(pScreen, buf, fmt, w, h) + ScreenPtr pScreen; + unsigned char *buf; + rfbPixelFormat *fmt; + int w, h; +{ + VNCSCREENPTR(pScreen); + CARD32 *buf32; + CARD32 pix32; + int *prevRowPtr; + int shiftBits[3]; + int pixHere[3], pixUpper[3], pixLeft[3], pixUpperLeft[3]; + int prediction; + int x, y, c; + + buf32 = (CARD32 *)buf; + memset (prevRowBuf, 0, w * 3 * sizeof(int)); + + if (!pVNC->rfbServerFormat.bigEndian == !fmt->bigEndian) { + shiftBits[0] = fmt->redShift; + shiftBits[1] = fmt->greenShift; + shiftBits[2] = fmt->blueShift; + } else { + shiftBits[0] = 24 - fmt->redShift; + shiftBits[1] = 24 - fmt->greenShift; + shiftBits[2] = 24 - fmt->blueShift; + } + + for (y = 0; y < h; y++) { + for (c = 0; c < 3; c++) { + pixUpper[c] = 0; + pixHere[c] = 0; + } + prevRowPtr = prevRowBuf; + for (x = 0; x < w; x++) { + pix32 = *buf32++; + for (c = 0; c < 3; c++) { + pixUpperLeft[c] = pixUpper[c]; + pixLeft[c] = pixHere[c]; + pixUpper[c] = *prevRowPtr; + pixHere[c] = (int)(pix32 >> shiftBits[c] & 0xFF); + *prevRowPtr++ = pixHere[c]; + + prediction = pixLeft[c] + pixUpper[c] - pixUpperLeft[c]; + if (prediction < 0) { + prediction = 0; + } else if (prediction > 0xFF) { + prediction = 0xFF; + } + *buf++ = (char)(pixHere[c] - prediction); + } + } + } +} + + +/* + * ``Gradient'' filter for other color depths. + */ + +#define DEFINE_GRADIENT_FILTER_FUNCTION(bpp) \ + \ +static void \ +FilterGradient##bpp(pScreen, buf, fmt, w, h) \ + ScreenPtr pScreen; \ + CARD##bpp *buf; \ + rfbPixelFormat *fmt; \ + int w, h; \ +{ \ + VNCSCREENPTR(pScreen); \ + CARD##bpp pix, diff; \ + Bool endianMismatch; \ + int *prevRowPtr; \ + int maxColor[3], shiftBits[3]; \ + int pixHere[3], pixUpper[3], pixLeft[3], pixUpperLeft[3]; \ + int prediction; \ + int x, y, c; \ + \ + memset (prevRowBuf, 0, w * 3 * sizeof(int)); \ + \ + endianMismatch = (!pVNC->rfbServerFormat.bigEndian != !fmt->bigEndian); \ + \ + maxColor[0] = fmt->redMax; \ + maxColor[1] = fmt->greenMax; \ + maxColor[2] = fmt->blueMax; \ + shiftBits[0] = fmt->redShift; \ + shiftBits[1] = fmt->greenShift; \ + shiftBits[2] = fmt->blueShift; \ + \ + for (y = 0; y < h; y++) { \ + for (c = 0; c < 3; c++) { \ + pixUpper[c] = 0; \ + pixHere[c] = 0; \ + } \ + prevRowPtr = prevRowBuf; \ + for (x = 0; x < w; x++) { \ + pix = *buf; \ + if (endianMismatch) { \ + pix = Swap##bpp(pix); \ + } \ + diff = 0; \ + for (c = 0; c < 3; c++) { \ + pixUpperLeft[c] = pixUpper[c]; \ + pixLeft[c] = pixHere[c]; \ + pixUpper[c] = *prevRowPtr; \ + pixHere[c] = (int)(pix >> shiftBits[c] & maxColor[c]); \ + *prevRowPtr++ = pixHere[c]; \ + \ + prediction = pixLeft[c] + pixUpper[c] - pixUpperLeft[c]; \ + if (prediction < 0) { \ + prediction = 0; \ + } else if (prediction > maxColor[c]) { \ + prediction = maxColor[c]; \ + } \ + diff |= ((pixHere[c] - prediction) & maxColor[c]) \ + << shiftBits[c]; \ + } \ + if (endianMismatch) { \ + diff = Swap##bpp(diff); \ + } \ + *buf++ = diff; \ + } \ + } \ +} + +DEFINE_GRADIENT_FILTER_FUNCTION(16) +DEFINE_GRADIENT_FILTER_FUNCTION(32) + + +/* + * Code to guess if given rectangle is suitable for smooth image + * compression (by applying "gradient" filter or JPEG coder). + */ + +#define JPEG_MIN_RECT_SIZE 4096 + +#define DETECT_SUBROW_WIDTH 7 +#define DETECT_MIN_WIDTH 8 +#define DETECT_MIN_HEIGHT 8 + +static int +DetectSmoothImage (cl, fmt, w, h) + rfbClientPtr cl; + rfbPixelFormat *fmt; + int w, h; +{ + VNCSCREENPTR(cl->pScreen); + unsigned long avgError; + + if ( pVNC->rfbServerFormat.bitsPerPixel == 8 || fmt->bitsPerPixel == 8 || + w < DETECT_MIN_WIDTH || h < DETECT_MIN_HEIGHT ) { + return 0; + } + + if (cl->tightQualityLevel != -1) { + if (w * h < JPEG_MIN_RECT_SIZE) { + return 0; + } + } else { + if ( rfbTightDisableGradient || + w * h < tightConf[cl->tightCompressLevel].gradientMinRectSize ) { + return 0; + } + } + + if (fmt->bitsPerPixel == 32) { + if (usePixelFormat24) { + avgError = DetectSmoothImage24(cl, fmt, w, h); + if (cl->tightQualityLevel != -1) { + return (avgError < tightConf[cl->tightQualityLevel].jpegThreshold24); + } + return (avgError < tightConf[cl->tightCompressLevel].gradientThreshold24); + } else { + avgError = DetectSmoothImage32(cl, fmt, w, h); + } + } else { + avgError = DetectSmoothImage16(cl, fmt, w, h); + } + if (cl->tightQualityLevel != -1) { + return (avgError < tightConf[cl->tightQualityLevel].jpegThreshold); + } + return (avgError < tightConf[cl->tightCompressLevel].gradientThreshold); +} + +static unsigned long +DetectSmoothImage24 (cl, fmt, w, h) + rfbClientPtr cl; + rfbPixelFormat *fmt; + int w, h; +{ + int off; + int x, y, d, dx, c; + int diffStat[256]; + int pixelCount = 0; + int pix, left[3]; + unsigned long avgError; + + /* If client is big-endian, color samples begin from the second + byte (offset 1) of a 32-bit pixel value. */ + off = (fmt->bigEndian != 0); + + memset(diffStat, 0, 256*sizeof(int)); + + y = 0, x = 0; + while (y < h && x < w) { + for (d = 0; d < h - y && d < w - x - DETECT_SUBROW_WIDTH; d++) { + for (c = 0; c < 3; c++) { + left[c] = (int)tightBeforeBuf[((y+d)*w+x+d)*4+off+c] & 0xFF; + } + for (dx = 1; dx <= DETECT_SUBROW_WIDTH; dx++) { + for (c = 0; c < 3; c++) { + pix = (int)tightBeforeBuf[((y+d)*w+x+d+dx)*4+off+c] & 0xFF; + diffStat[abs(pix - left[c])]++; + left[c] = pix; + } + pixelCount++; + } + } + if (w > h) { + x += h; + y = 0; + } else { + x = 0; + y += w; + } + } + + if (diffStat[0] * 33 / pixelCount >= 95) + return 0; + + avgError = 0; + for (c = 1; c < 8; c++) { + avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c); + if (diffStat[c] == 0 || diffStat[c] > diffStat[c-1] * 2) + return 0; + } + for (; c < 256; c++) { + avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c); + } + avgError /= (pixelCount * 3 - diffStat[0]); + + return avgError; +} + +#define DEFINE_DETECT_FUNCTION(bpp) \ + \ +static unsigned long \ +DetectSmoothImage##bpp (cl, fmt, w, h) \ + rfbClientPtr cl; \ + rfbPixelFormat *fmt; \ + int w, h; \ +{ \ + VNCSCREENPTR(cl->pScreen); \ + Bool endianMismatch; \ + CARD##bpp pix; \ + int maxColor[3], shiftBits[3]; \ + int x, y, d, dx, c; \ + int diffStat[256]; \ + int pixelCount = 0; \ + int sample, sum, left[3]; \ + unsigned long avgError; \ + \ + endianMismatch = (!pVNC->rfbServerFormat.bigEndian != !fmt->bigEndian); \ + \ + maxColor[0] = fmt->redMax; \ + maxColor[1] = fmt->greenMax; \ + maxColor[2] = fmt->blueMax; \ + shiftBits[0] = fmt->redShift; \ + shiftBits[1] = fmt->greenShift; \ + shiftBits[2] = fmt->blueShift; \ + \ + memset(diffStat, 0, 256*sizeof(int)); \ + \ + y = 0, x = 0; \ + while (y < h && x < w) { \ + for (d = 0; d < h - y && d < w - x - DETECT_SUBROW_WIDTH; d++) { \ + pix = ((CARD##bpp *)tightBeforeBuf)[(y+d)*w+x+d]; \ + if (endianMismatch) { \ + pix = Swap##bpp(pix); \ + } \ + for (c = 0; c < 3; c++) { \ + left[c] = (int)(pix >> shiftBits[c] & maxColor[c]); \ + } \ + for (dx = 1; dx <= DETECT_SUBROW_WIDTH; dx++) { \ + pix = ((CARD##bpp *)tightBeforeBuf)[(y+d)*w+x+d+dx]; \ + if (endianMismatch) { \ + pix = Swap##bpp(pix); \ + } \ + sum = 0; \ + for (c = 0; c < 3; c++) { \ + sample = (int)(pix >> shiftBits[c] & maxColor[c]); \ + sum += abs(sample - left[c]); \ + left[c] = sample; \ + } \ + if (sum > 255) \ + sum = 255; \ + diffStat[sum]++; \ + pixelCount++; \ + } \ + } \ + if (w > h) { \ + x += h; \ + y = 0; \ + } else { \ + x = 0; \ + y += w; \ + } \ + } \ + \ + if ((diffStat[0] + diffStat[1]) * 100 / pixelCount >= 90) \ + return 0; \ + \ + avgError = 0; \ + for (c = 1; c < 8; c++) { \ + avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c); \ + if (diffStat[c] == 0 || diffStat[c] > diffStat[c-1] * 2) \ + return 0; \ + } \ + for (; c < 256; c++) { \ + avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c); \ + } \ + avgError /= (pixelCount - diffStat[0]); \ + \ + return avgError; \ +} + +DEFINE_DETECT_FUNCTION(16) +DEFINE_DETECT_FUNCTION(32) + + +/* + * JPEG compression stuff. + */ + +static struct jpeg_destination_mgr jpegDstManager; +static Bool jpegError; +static int jpegDstDataLen; + +/** + * Send the given image rect with jpeg compression. + * \param buffer the source image buffer + * \param w width of source image in pixels + * \param h height of source image in pixels + * \param quality jpeg enoding quality + */ +static Bool +SendJpegRect(rfbClientPtr cl, const CARD8 *buffer, int w, int h, + int quality) +{ + VNCSCREENPTR(cl->pScreen); + struct jpeg_compress_struct cinfo; + struct jpeg_error_mgr jerr; + CARD8 *srcBuf; + JSAMPROW rowPointer[1]; + int i; + + if (pVNC->rfbServerFormat.bitsPerPixel == 8) + return SendFullColorRect(cl, w, h); + + srcBuf = (CARD8 *)xalloc(w * 3); + if (srcBuf == NULL) { + return SendFullColorRect(cl, w, h); + } + rowPointer[0] = srcBuf; + + cinfo.err = jpeg_std_error(&jerr); + jpeg_create_compress(&cinfo); + + cinfo.image_width = w; + cinfo.image_height = h; + cinfo.input_components = 3; + cinfo.in_color_space = JCS_RGB; + + jpeg_set_defaults(&cinfo); + jpeg_set_quality(&cinfo, quality, TRUE); + + JpegSetDstManager (&cinfo); + + jpeg_start_compress(&cinfo, TRUE); + + for (i = 0; i < h; i++) { + PrepareRowForJpeg(cl->pScreen, srcBuf, buffer, i, w); + jpeg_write_scanlines(&cinfo, rowPointer, 1); + if (jpegError) + break; + } + + if (!jpegError) + jpeg_finish_compress(&cinfo); + + jpeg_destroy_compress(&cinfo); + xfree((char *)srcBuf); + + if (jpegError) + return SendFullColorRect(cl, w, h); + + if (pVNC->ublen + TIGHT_MIN_TO_COMPRESS + 1 > UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + pVNC->updateBuf[pVNC->ublen++] = (char)(rfbTightJpeg << 4); + cl->rfbBytesSent[rfbEncodingTight]++; + + return SendCompressedData(cl, jpegDstDataLen); +} + +/** + * Convert pixel data to format needed for jpeg library. + * \dst destination buffer (24bpp) + * \buffer source buffer (16 or 32bpp) + * \row which image row to prepare/convert + * \width width of source buffer, in pixels + */ +static void +PrepareRowForJpeg(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, + int row, int width) +{ + VNCSCREENPTR(pScreen); + if (pVNC->rfbServerFormat.bitsPerPixel == 32) { + if ( pVNC->rfbServerFormat.redMax == 0xFF && + pVNC->rfbServerFormat.greenMax == 0xFF && + pVNC->rfbServerFormat.blueMax == 0xFF ) { + PrepareRowForJpeg24(pScreen, dst, buffer, row, width); + } else { + PrepareRowForJpeg32(pScreen, dst, buffer, row, width); + } + } else { + /* 16 bpp assumed. */ + PrepareRowForJpeg16(pScreen, dst, buffer, row, width); + } +} + +/** + * Src buffer is 32bpp, dst buffer is 24bpp (optimized case). + */ +static void +PrepareRowForJpeg24(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, + int row, int width) +{ + VNCSCREENPTR(pScreen); + const CARD32 *src = ((const CARD32 *) buffer) + row * width; + while (width--) { + CARD32 pix = *src++; + *dst++ = (CARD8)(pix >> pVNC->rfbServerFormat.redShift); + *dst++ = (CARD8)(pix >> pVNC->rfbServerFormat.greenShift); + *dst++ = (CARD8)(pix >> pVNC->rfbServerFormat.blueShift); + } +} + +/** + * PrepareRowForJpeg16/32: convert 16bpp or 32bpp pixels to 24bpp + */ +#define DEFINE_JPEG_GET_ROW_FUNCTION(bpp) \ + \ +static void \ +PrepareRowForJpeg##bpp(ScreenPtr pScreen, CARD8 *dst, const CARD8 *buffer, \ + int row, int width) \ +{ \ + VNCSCREENPTR(pScreen); \ + CARD##bpp *fbptr; \ + CARD##bpp pix; \ + int inRed, inGreen, inBlue; \ + \ + fbptr = ((CARD##bpp *) buffer) + row * width; \ + \ + while (width--) { \ + pix = *fbptr++; \ + \ + inRed = (int) \ + (pix >> pVNC->rfbServerFormat.redShift & pVNC->rfbServerFormat.redMax); \ + inGreen = (int) \ + (pix >> pVNC->rfbServerFormat.greenShift & pVNC->rfbServerFormat.greenMax); \ + inBlue = (int) \ + (pix >> pVNC->rfbServerFormat.blueShift & pVNC->rfbServerFormat.blueMax); \ + \ + *dst++ = (CARD8)((inRed * 255 + pVNC->rfbServerFormat.redMax / 2) / \ + pVNC->rfbServerFormat.redMax); \ + *dst++ = (CARD8)((inGreen * 255 + pVNC->rfbServerFormat.greenMax / 2) / \ + pVNC->rfbServerFormat.greenMax); \ + *dst++ = (CARD8)((inBlue * 255 + pVNC->rfbServerFormat.blueMax / 2) / \ + pVNC->rfbServerFormat.blueMax); \ + } \ +} + +DEFINE_JPEG_GET_ROW_FUNCTION(16) +DEFINE_JPEG_GET_ROW_FUNCTION(32) + +/* + * Destination manager implementation for JPEG library. + */ + +static void +JpegInitDestination(j_compress_ptr cinfo) +{ + jpegError = FALSE; + jpegDstManager.next_output_byte = (JOCTET *)tightAfterBuf; + jpegDstManager.free_in_buffer = (size_t)tightAfterBufSize; +} + +static boolean +JpegEmptyOutputBuffer(j_compress_ptr cinfo) +{ + jpegError = TRUE; + jpegDstManager.next_output_byte = (JOCTET *)tightAfterBuf; + jpegDstManager.free_in_buffer = (size_t)tightAfterBufSize; + + return TRUE; +} + +static void +JpegTermDestination(j_compress_ptr cinfo) +{ + jpegDstDataLen = tightAfterBufSize - jpegDstManager.free_in_buffer; +} + +static void +JpegSetDstManager(j_compress_ptr cinfo) +{ + jpegDstManager.init_destination = JpegInitDestination; + jpegDstManager.empty_output_buffer = JpegEmptyOutputBuffer; + jpegDstManager.term_destination = JpegTermDestination; + cinfo->dest = &jpegDstManager; +} + diff -pNur xorg-server-1.4.orig/hw/vnc/translate.c xorg-server-1.4/hw/vnc/translate.c --- xorg-server-1.4.orig/hw/vnc/translate.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/translate.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,502 @@ +/* + * translate.c - translate between different pixel formats + * + * 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" +#if XFREE86VNC +#include <micmap.h> +#endif + +static void PrintPixelFormat(rfbPixelFormat *pf); +static Bool rfbSetClientColourMapBGR233(rfbClientPtr cl); + +Bool rfbEconomicTranslate = FALSE; + +/* + * Some standard pixel formats. + */ + +static const rfbPixelFormat BGR233Format = { + 8, 8, 0, 1, 7, 7, 3, 0, 3, 6 +}; + + +/* + * Macro to compare pixel formats. + */ + +#define PF_EQ(x,y) \ + ((x.bitsPerPixel == y.bitsPerPixel) && \ + (x.depth == y.depth) && \ + ((x.bigEndian == y.bigEndian) || (x.bitsPerPixel == 8)) && \ + (x.trueColour == y.trueColour) && \ + (!x.trueColour || ((x.redMax == y.redMax) && \ + (x.greenMax == y.greenMax) && \ + (x.blueMax == y.blueMax) && \ + (x.redShift == y.redShift) && \ + (x.greenShift == y.greenShift) && \ + (x.blueShift == y.blueShift)))) + +#define CONCAT2(a,b) a##b +#define CONCAT2E(a,b) CONCAT2(a,b) +#define CONCAT4(a,b,c,d) a##b##c##d +#define CONCAT4E(a,b,c,d) CONCAT4(a,b,c,d) + +#define OUT 8 +#include "tableinittctemplate.c" +#include "tableinitcmtemplate.c" +#define IN 8 +#include "tabletranstemplate.c" +#undef IN +#define IN 16 +#include "tabletranstemplate.c" +#undef IN +#define IN 32 +#include "tabletranstemplate.c" +#undef IN +#undef OUT + +#define OUT 16 +#include "tableinittctemplate.c" +#include "tableinitcmtemplate.c" +#define IN 8 +#include "tabletranstemplate.c" +#undef IN +#define IN 16 +#include "tabletranstemplate.c" +#undef IN +#define IN 32 +#include "tabletranstemplate.c" +#undef IN +#undef OUT + +#define OUT 32 +#include "tableinittctemplate.c" +#include "tableinitcmtemplate.c" +#define IN 8 +#include "tabletranstemplate.c" +#undef IN +#define IN 16 +#include "tabletranstemplate.c" +#undef IN +#define IN 32 +#include "tabletranstemplate.c" +#undef IN +#undef OUT + +typedef void (*rfbInitTableFnType)(ScreenPtr pScreen, char **table, rfbPixelFormat *in, + rfbPixelFormat *out); + +rfbInitTableFnType rfbInitTrueColourSingleTableFns[3] = { + rfbInitTrueColourSingleTable8, + rfbInitTrueColourSingleTable16, + rfbInitTrueColourSingleTable32 +}; + +rfbInitTableFnType rfbInitColourMapSingleTableFns[3] = { + rfbInitColourMapSingleTable8, + rfbInitColourMapSingleTable16, + rfbInitColourMapSingleTable32 +}; + +rfbInitTableFnType rfbInitTrueColourRGBTablesFns[3] = { + rfbInitTrueColourRGBTables8, + rfbInitTrueColourRGBTables16, + rfbInitTrueColourRGBTables32 +}; + +rfbTranslateFnType rfbTranslateWithSingleTableFns[3][3] = { + { rfbTranslateWithSingleTable8to8, + rfbTranslateWithSingleTable8to16, + rfbTranslateWithSingleTable8to32 }, + { rfbTranslateWithSingleTable16to8, + rfbTranslateWithSingleTable16to16, + rfbTranslateWithSingleTable16to32 }, + { rfbTranslateWithSingleTable32to8, + rfbTranslateWithSingleTable32to16, + rfbTranslateWithSingleTable32to32 } +}; + +rfbTranslateFnType rfbTranslateWithRGBTablesFns[3][3] = { + { rfbTranslateWithRGBTables8to8, + rfbTranslateWithRGBTables8to16, + rfbTranslateWithRGBTables8to32 }, + { rfbTranslateWithRGBTables16to8, + rfbTranslateWithRGBTables16to16, + rfbTranslateWithRGBTables16to32 }, + { rfbTranslateWithRGBTables32to8, + rfbTranslateWithRGBTables32to16, + rfbTranslateWithRGBTables32to32 } +}; + + + +/* + * rfbTranslateNone is used when no translation is required. + */ + +void +rfbTranslateNone(ScreenPtr pScreen, char *table, rfbPixelFormat *in, rfbPixelFormat *out, + unsigned char *optr, int bytesBetweenInputLines, + int width, int height, int x, int y) +{ + VNCSCREENPTR(pScreen); + DrawablePtr pDraw = (DrawablePtr)WindowTable[pScreen->myNum]; + int truewidth = PixmapBytePad(width, in->bitsPerPixel) / 4; + + if ((x + truewidth > pVNC->width) || truewidth != width) { + unsigned char *buffer = malloc(truewidth * height * in->bitsPerPixel / 8); + unsigned char *buf = buffer; + + (*pScreen->GetImage)(pDraw, x, y, truewidth, height, ZPixmap, ~0, (char*)buf); + while (height--) { + memcpy(optr, buf, width * in->bitsPerPixel / 8); + optr += width * in->bitsPerPixel / 8; + buf += truewidth * in->bitsPerPixel / 8; + } + free(buffer); + return; + } + + (*pScreen->GetImage)(pDraw, x, y, width, height, ZPixmap, ~0, (char*)optr); +} + + +/* + * rfbSetTranslateFunction sets the translation function. + */ + +Bool +rfbSetTranslateFunction(cl) + rfbClientPtr cl; +{ + VNCSCREENPTR(cl->pScreen); + rfbLog("Pixel format for client %s:\n",cl->host); + PrintPixelFormat(&cl->format); + + /* + * Check that bits per pixel values are valid + */ + + if ((pVNC->rfbServerFormat.bitsPerPixel != 8) && + (pVNC->rfbServerFormat.bitsPerPixel != 16) && + (pVNC->rfbServerFormat.bitsPerPixel != 32)) + { + rfbLog("%s: server bits per pixel not 8, 16 or 32\n", + "rfbSetTranslateFunction"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + if ((cl->format.bitsPerPixel != 8) && + (cl->format.bitsPerPixel != 16) && + (cl->format.bitsPerPixel != 32)) + { + rfbLog("%s: client bits per pixel not 8, 16 or 32\n", + "rfbSetTranslateFunction"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + if (!pVNC->rfbServerFormat.trueColour && + (pVNC->rfbServerFormat.bitsPerPixel != 8) && +#if XFREE86VNC + (miInstalledMaps[cl->pScreen->myNum]->class == PseudoColor)) { +#else + (pVNC->rfbInstalledColormap->class == PseudoColor)) { +#endif + rfbLog("rfbSetTranslateFunction: server has colour map " + "but %d-bit - can only cope with 8-bit colour maps\n", + pVNC->rfbServerFormat.bitsPerPixel); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + if (!cl->format.trueColour && + (cl->format.bitsPerPixel != 8) && +#if XFREE86VNC + (miInstalledMaps[cl->pScreen->myNum]->class == PseudoColor)) { +#else + (pVNC->rfbInstalledColormap->class == PseudoColor) ) { +#endif + rfbLog("rfbSetTranslateFunction: client has colour map " + "but %d-bit - can only cope with 8-bit colour maps\n", + cl->format.bitsPerPixel); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + /* + * bpp is valid, now work out how to translate + */ + + if (!cl->format.trueColour) { + + /* ? -> colour map */ + + if (!pVNC->rfbServerFormat.trueColour) { + + /* colour map -> colour map */ + +#if XFREE86VNC + if (miInstalledMaps[cl->pScreen->myNum]->class == DirectColor) { +#else + if (pVNC->rfbInstalledColormap->class == DirectColor) { +#endif + rfbLog("rfbSetTranslateFunction: client is %d-bit DirectColor," + " client has colour map\n",cl->format.bitsPerPixel); + + cl->translateFn = rfbTranslateWithRGBTablesFns + [pVNC->rfbServerFormat.bitsPerPixel / 16] + [cl->format.bitsPerPixel / 16]; + + (*rfbInitTrueColourRGBTablesFns [cl->format.bitsPerPixel / 16]) + (cl->pScreen, &cl->translateLookupTable, + &pVNC->rfbServerFormat, &cl->format); + + return rfbSetClientColourMap(cl, 0, 0); + + /* PseudoColor colormap */ + + } else { + rfbLog("rfbSetTranslateFunction: both 8-bit colour map: " + "no translation needed\n"); + cl->translateFn = rfbTranslateNone; + return rfbSetClientColourMap(cl, 0, 0); + } + } + + /* + * truecolour -> colour map + * + * Set client's colour map to BGR233, then effectively it's + * truecolour as well + */ + + if (!rfbSetClientColourMapBGR233(cl)) + return FALSE; + + cl->format = BGR233Format; + } + + /* ? -> truecolour */ + + if (!pVNC->rfbServerFormat.trueColour) { + + /* colour map -> truecolour */ + + rfbLog("rfbSetTranslateFunction: client is %d-bit trueColour," + " server has colour map\n",cl->format.bitsPerPixel); + + cl->translateFn = rfbTranslateWithSingleTableFns + [pVNC->rfbServerFormat.bitsPerPixel / 16] + [cl->format.bitsPerPixel / 16]; + + return rfbSetClientColourMap(cl, 0, 0); + } + + /* truecolour -> truecolour */ + + if (PF_EQ(cl->format,pVNC->rfbServerFormat)) { + + /* client & server the same */ + + rfbLog(" no translation needed\n"); + cl->translateFn = rfbTranslateNone; + return TRUE; + } + + if ((pVNC->rfbServerFormat.bitsPerPixel < 16) || + (!rfbEconomicTranslate && (pVNC->rfbServerFormat.bitsPerPixel == 16))) { + + /* we can use a single lookup table for <= 16 bpp */ + + cl->translateFn = rfbTranslateWithSingleTableFns + [pVNC->rfbServerFormat.bitsPerPixel / 16] + [cl->format.bitsPerPixel / 16]; + + (*rfbInitTrueColourSingleTableFns + [cl->format.bitsPerPixel / 16]) (cl->pScreen, + &cl->translateLookupTable, + &pVNC->rfbServerFormat, &cl->format); + + } else { + + /* otherwise we use three separate tables for red, green and blue */ + + cl->translateFn = rfbTranslateWithRGBTablesFns + [pVNC->rfbServerFormat.bitsPerPixel / 16] + [cl->format.bitsPerPixel / 16]; + + (*rfbInitTrueColourRGBTablesFns + [cl->format.bitsPerPixel / 16]) (cl->pScreen, + &cl->translateLookupTable, + &pVNC->rfbServerFormat, &cl->format); + } + + return TRUE; +} + + + +/* + * rfbSetClientColourMapBGR233 sets the client's colour map so that it's + * just like an 8-bit BGR233 true colour client. + */ + +static Bool +rfbSetClientColourMapBGR233(rfbClientPtr cl) +{ + char buf[sz_rfbSetColourMapEntriesMsg + 256 * 3 * 2]; + rfbSetColourMapEntriesMsg *scme = (rfbSetColourMapEntriesMsg *)buf; + CARD16 *rgb = (CARD16 *)(&buf[sz_rfbSetColourMapEntriesMsg]); + int i, len; + int r, g, b; + + if (cl->format.bitsPerPixel != 8) { + rfbLog("%s: client not 8 bits per pixel\n", + "rfbSetClientColourMapBGR233"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + + scme->type = rfbSetColourMapEntries; + + scme->firstColour = Swap16IfLE(0); + scme->nColours = Swap16IfLE(256); + + len = sz_rfbSetColourMapEntriesMsg; + + i = 0; + + for (b = 0; b < 4; b++) { + for (g = 0; g < 8; g++) { + for (r = 0; r < 8; r++) { + rgb[i++] = Swap16IfLE(r * 65535 / 7); + rgb[i++] = Swap16IfLE(g * 65535 / 7); + rgb[i++] = Swap16IfLE(b * 65535 / 3); + } + } + } + + len += 256 * 3 * 2; + + if (WriteExact(cl->sock, buf, len) < 0) { + rfbLogPerror("rfbSetClientColourMapBGR233: write"); + rfbCloseSock(cl->pScreen, cl->sock); + return FALSE; + } + return TRUE; +} + + +/* + * rfbSetClientColourMap is called to set the client's colour map. If the + * client is a true colour client, we simply update our own translation table + * and mark the whole screen as having been modified. + */ + +Bool +rfbSetClientColourMap(cl, firstColour, nColours) + rfbClientPtr cl; + int firstColour; + int nColours; +{ + VNCSCREENPTR(cl->pScreen); + BoxRec box; + + if (nColours == 0) { +#if XFREE86VNC + nColours = miInstalledMaps[cl->pScreen->myNum]->pVisual->ColormapEntries; +#else + nColours = pVNC->rfbInstalledColormap->pVisual->ColormapEntries; +#endif + } + + if (pVNC->rfbServerFormat.trueColour || !cl->readyForSetColourMapEntries) { + return TRUE; + } + + if (cl->format.trueColour) { + (*rfbInitColourMapSingleTableFns + [cl->format.bitsPerPixel / 16]) (cl->pScreen, + &cl->translateLookupTable, + &pVNC->rfbServerFormat, &cl->format); + + REGION_UNINIT(cl->pScreen,&cl->modifiedRegion); + box.x1 = box.y1 = 0; + box.x2 = pVNC->width; + box.y2 = pVNC->height; + REGION_INIT(cl->pScreen,&cl->modifiedRegion,&box,0); + + return TRUE; + } + + return rfbSendSetColourMapEntries(cl, firstColour, nColours); +} + + +/* + * rfbSetClientColourMaps sets the colour map for each RFB client. + */ + +void +rfbSetClientColourMaps(firstColour, nColours) + int firstColour; + int nColours; +{ + rfbClientPtr cl, nextCl; + + for (cl = rfbClientHead; cl; cl = nextCl) { + nextCl = cl->next; + rfbSetClientColourMap(cl, firstColour, nColours); + } +} + + +static void +PrintPixelFormat(pf) + rfbPixelFormat *pf; +{ + if (pf->bitsPerPixel == 1) { + rfbLog(" 1 bpp, %s sig bit in each byte is leftmost on the screen.\n", + (pf->bigEndian ? "most" : "least")); + } else { + rfbLog(" %d bpp, depth %d%s\n",pf->bitsPerPixel,pf->depth, + ((pf->bitsPerPixel == 8) ? "" + : (pf->bigEndian ? ", big endian" : ", little endian"))); + if (pf->trueColour) { + rfbLog(" true colour: max r %d g %d b %d, shift r %d g %d b %d\n", + pf->redMax, pf->greenMax, pf->blueMax, + pf->redShift, pf->greenShift, pf->blueShift); + } else { + rfbLog(" uses a colour map (not true colour).\n"); + } + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/vncauth.c xorg-server-1.4/hw/vnc/vncauth.c --- xorg-server-1.4.orig/hw/vnc/vncauth.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/vncauth.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,252 @@ +/* + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * vncauth.c - Functions for VNC password management and authentication. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <time.h> +#include <unistd.h> +#include <vncauth.h> +#include <d3des.h> + + +/* + * Make sure we call srandom() only once. + */ + +static int s_srandom_called = 0; + +/* + * We use a fixed key to store passwords, since we assume that our local + * file system is secure but nonetheless don't want to store passwords + * as plaintext. + */ + +static unsigned char s_fixedkey[8] = {23,82,107,6,35,78,88,7}; + + +/* + * Encrypt a password and store it in a file. Returns 0 if successful, + * 1 if the file could not be written. + * + * NOTE: This function is preserved only for compatibility with the original + * AT&T VNC software. Use vncEncryptAndStorePasswd2() instead. + */ + +int +vncEncryptAndStorePasswd(char *passwd, char *fname) +{ + return (vncEncryptAndStorePasswd2(passwd, NULL, fname) == 0); +} + +/* + * Encrypt one or two passwords and store them in a file. Returns 1 if + * successful, 0 if the file could not be written (note that the original + * vncEncryptAndStorePasswd() function returns inverse values). The + * passwdViewOnly pointer may be NULL. + * + * NOTE: The file name of "-" denotes stdout. + */ + +int +vncEncryptAndStorePasswd2(char *passwd, char *passwdViewOnly, char *fname) +{ + FILE *fp; + int bytesToWrite, bytesWrote; + unsigned char encryptedPasswd[16] = { + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0 + }; + + if (strcmp(fname, "-") != 0) { + fp = fopen(fname, "w"); + if (fp == NULL) { + return 0; + } + chmod(fname, S_IRUSR|S_IWUSR); + } else { + fp = stdout; + } + + strncpy((char*)encryptedPasswd, passwd, 8); + if (passwdViewOnly != NULL) + strncpy((char*)encryptedPasswd + 8, passwdViewOnly, 8); + + /* Do encryption in-place - this way we overwrite our copies of + plaintext passwords. */ + + deskey(s_fixedkey, EN0); + des(encryptedPasswd, encryptedPasswd); + if (passwdViewOnly != NULL) + des(encryptedPasswd + 8, encryptedPasswd + 8); + + bytesToWrite = (passwdViewOnly == NULL) ? 8 : 16; + bytesWrote = fwrite(encryptedPasswd, 1, bytesToWrite, fp); + + if (fp != stdout) { + fclose(fp); + } + return (bytesWrote == bytesToWrite); +} + + +/* + * Decrypt a password from a file. Returns a pointer to a newly allocated + * string containing the password or a null pointer if the password could + * not be retrieved for some reason. + * + * NOTE: This function is preserved only for compatibility with the original + * AT&T VNC software. Use vncDecryptPasswdFromFile2() instead. + */ + +char * +vncDecryptPasswdFromFile(char *fname) +{ + char *passwd; + + passwd = malloc(9); + + if (passwd != NULL) { + if (vncDecryptPasswdFromFile2(fname, passwd, NULL) == 0) { + free(passwd); + passwd = NULL; + } + } + + return passwd; +} + +/* + * Decrypt one or two passwords from a file. Returns the number of + * passwords read (1, 2, or 0 on error). On success, the passwords are + * written into buffers passwdFullControl[] and passwdViewOnly[] if + * they are not NULL. If the pointers to buffers are not NULL, then + * the buffers should be at least of 9 bytes length. + */ + +int +vncDecryptPasswdFromFile2(char *fname, + char *passwdFullControl, char *passwdViewOnly) +{ + FILE *fp; + int i, ch; + unsigned char passwd[16]; + + if (strcmp(fname, "-") != 0) { + if ((fp = fopen(fname,"r")) == NULL) + return 0; /* Could not open the file */ + } else { + fp = stdin; + } + + for (i = 0; i < 16; i++) { + ch = getc(fp); + if (ch == EOF) + break; + passwd[i] = ch; + } + + if (fp != stdin) + fclose(fp); + + if (i < 8) + return 0; /* Could not read eight bytes */ + + deskey(s_fixedkey, DE1); + + /* Decoding first (full-control) password */ + if (passwdFullControl != NULL) { + des(passwd, passwd); + memcpy(passwdFullControl, passwd, 8); + passwdFullControl[8] = '\0'; + } + + /* Decoding second (view-only) password if available */ + if (i == 16 && passwdViewOnly != NULL) { + des(&passwd[8], &passwd[8]); + memcpy(passwdViewOnly, &passwd[8], 8); + passwdViewOnly[8] = '\0'; + } + + /* Destroying our copy of clear-text passwords */ + memset(passwd, 0, 16); + + return (i < 16) ? 1 : 2; +} + + +/* + * Generate CHALLENGESIZE random bytes for use in challenge-response + * authentication. + */ + +void +vncRandomBytes(unsigned char *bytes) +{ + int i; + unsigned int seed; + + if (!s_srandom_called) { + seed = (unsigned int)time(0) ^ (unsigned int)getpid(); + srandom(seed); + s_srandom_called = 1; + } + + for (i = 0; i < CHALLENGESIZE; i++) { + bytes[i] = (unsigned char)(random() & 255); + } +} + + +/* + * Encrypt CHALLENGESIZE bytes in memory using a password. + */ + +void +vncEncryptBytes(unsigned char *bytes, char *passwd) +{ + unsigned char key[8]; + int i; + + /* key is simply password padded with nulls */ + + for (i = 0; i < 8; i++) { + if (i < strlen(passwd)) { + key[i] = passwd[i]; + } else { + key[i] = 0; + } + } + + deskey(key, EN0); + + for (i = 0; i < CHALLENGESIZE; i += 8) { + des(bytes+i, bytes+i); + } +} diff -pNur xorg-server-1.4.orig/hw/vnc/vncauth.h xorg-server-1.4/hw/vnc/vncauth.h --- xorg-server-1.4.orig/hw/vnc/vncauth.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/vncauth.h 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,33 @@ +/* + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * vncauth.h - describes the functions provided by the vncauth library. + */ + +#define MAXPWLEN 8 +#define CHALLENGESIZE 16 + +extern int vncEncryptAndStorePasswd(char *passwd, char *fname); +extern char *vncDecryptPasswdFromFile(char *fname); +extern void vncRandomBytes(unsigned char *bytes); +extern void vncEncryptBytes(unsigned char *bytes, char *passwd); +extern int vncEncryptAndStorePasswd2(char *passwd, char *passwdViewOnly, char *fname); +extern int vncDecryptPasswdFromFile2(char *fname, char *passwdFullControl, char *passwdViewOnly); + diff -pNur xorg-server-1.4.orig/hw/vnc/vncext.c xorg-server-1.4/hw/vnc/vncext.c --- xorg-server-1.4.orig/hw/vnc/vncext.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/vncext.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,798 @@ +/* + * 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> + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include "rfb.h" +#include "extnsionst.h" +#define _VNC_SERVER +#include <X11/extensions/vncstr.h> +#ifdef XFree86LOADER +#include "xf86Module.h" +#endif + +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <netdb.h> + +int VncSelectNotify(ClientPtr client, BOOL onoff); +void VncExtensionInit(void); + +static int VncErrorBase; /* first vnc error number */ +static int VncEventBase; /* first vnc event number */ + +#define USE_ORIG_RES_CODE 0 + +#if USE_ORIG_RES_CODE +unsigned long VncResourceGeneration = 0; + +static RESTYPE VncNotifyList; + +static XID faked; + +typedef struct _VncNotifyListRec { + struct _VncNotifyListRec *next; + ClientPtr client; +} VncNotifyListRec, *VncNotifyListPtr; +#endif + + +/** + * Each X client that uses libVnc to talk to this extension will + * get recorded by one of these records. + */ +typedef struct _VncClientRec { + ClientPtr client; + struct _VncClientRec *next; + XID fakeID; + RESTYPE res; +} VncClientRec, *VncClientRecPtr; + +static VncClientRecPtr ClientsList = NULL; + + +/** + * Remove client record from list + */ +static void +VncRemoveClientRecord(ClientPtr client) +{ + /* XXX need 'deleteresource' flag? */ + VncClientRecPtr p = ClientsList, prev = NULL; + rfbLog("%s client %p\n", __func__, (void *) client); + while (p) { + if (p->client == client) { + /* remove this one */ + if (prev) + prev->next = p->next; + else + ClientsList = p->next; + xfree(p); + return; + } + prev = p; + p = p->next; + } +} + + +/** + * This callback will be called by X's resource manager to delete the + * given resource. We create one resource for each client. When X + * deletes the resource, we know the client is going away. + */ +static int +VncDestroyClientResourceCallback(pointer pn, XID id) +{ + VncClientRecPtr rec = (VncClientRecPtr) pn; + VncRemoveClientRecord(rec->client); + return Success; +} + + +/** + * Add a client record to the list of clients (unless already in list). + * We'll create a new, unique resource for this client. This is used + * to detect when an X client goes away. + */ +static void +VncSaveClientRecord(ClientPtr client) +{ + VncClientRecPtr rec = ClientsList; + + rfbLog("%s saving client %p\n", __func__, (void *) client); + + /* look if already in list */ + while (rec) { + if (rec->client == client) { + return; /* already in list */ + } + rec = rec->next; + } + + /* allocate new client record */ + rec = (VncClientRecPtr) xalloc(sizeof(VncClientRec)); + if (rec) { + rec->client = client; + rec->fakeID = FakeClientID(client->index); + rec->res = CreateNewResourceType(VncDestroyClientResourceCallback); + if (!AddResource(rec->fakeID, rec->res, rec)) { + xfree(rec); + } + + /* insert at head of list */ + rec->next = ClientsList; + ClientsList = rec; + } +} + + + +static int +ProcVncQueryVersion(ClientPtr client) +{ + xVncQueryVersionReply rep; + + REQUEST_SIZE_MATCH(xVncQueryVersionReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.majorVersion = VNC_MAJOR_VERSION; + rep.minorVersion = VNC_MINOR_VERSION; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + swaps(&rep.majorVersion, n); + swaps(&rep.minorVersion, n); + } + (void)WriteToClient(client, SIZEOF(xVncQueryVersionReply), + (char *)&rep); + return (client->noClientException); +} /* ProcVncQueryVersion */ + +static int +ProcVncConnection(ClientPtr client) +{ + REQUEST(xVncConnectionReq); + xVncConnectionReply rep; + + rfbUserAllow( stuff->sock, stuff->accept ); + + REQUEST_SIZE_MATCH(xVncConnectionReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.sock = 0; + rep.accept = 0; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + swaps(&rep.sock, n); + swaps(&rep.accept, n); + } + (void)WriteToClient(client, SIZEOF(xVncConnectionReply), + (char *)&rep); + return (client->noClientException); +} /* ProcVncConnection */ + +static int +ProcVncSelectNotify(ClientPtr client) +{ + REQUEST(xVncSelectNotifyReq); + xVncSelectNotifyReply rep; + + VncSelectNotify(client, stuff->onoff); + + REQUEST_SIZE_MATCH(xVncSelectNotifyReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + } + (void)WriteToClient(client, SIZEOF(xVncSelectNotifyReply), + (char *)&rep); + return (client->noClientException); + +} + +static int +ProcVncListConnections(ClientPtr client) +{ + xVncListConnectionsReply rep; + rfbClientPtr cl; + int count = 0; + struct in_addr ipaddress; + xVncConnectionListInfo Info; + + /* count connections */ + for (cl = rfbClientHead; cl; cl = cl->next) +#ifdef CHROMIUM + /* + * Fix this, as it should be generic, but we're only using it + * for Chromium at the moment, so we only list the connections + * that have a valid chromium encoding. We should be able to list + * any type requested. FIXME! XXXX + * See furthur down this function too!!! + */ + if (cl->enableChromiumEncoding) +#endif + count++; + + REQUEST_SIZE_MATCH(xVncListConnectionsReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.count = count; + rep.length = count * sizeof(xVncConnectionListInfo) >> 2; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + swaps(&rep.count, n); + } + (void)WriteToClient(client, SIZEOF(xVncListConnectionsReply), + (char *)&rep); + + for (cl = rfbClientHead; cl; cl = cl->next) { +#ifdef CHROMIUM + /* + * Fix this, as it should be generic, but we're only using it + * for Chromium at the moment, so we only list the connections + * that have a valid chromium encoding. We should be able to list + * any type requested. FIXME! XXXX + */ + if (!cl->enableChromiumEncoding) + continue; +#endif + inet_aton(cl->host, &ipaddress); + memcpy(&Info, &ipaddress, sizeof(struct in_addr)); + WriteToClient(client, SIZEOF(xVncConnectionListInfo), (char*)&Info); + } + + return (client->noClientException); +} /* ProcVncListConnections */ + +#ifdef CHROMIUM +static int +ProcVncChromiumStart(ClientPtr client) +{ + REQUEST(xVncChromiumStartReq); + xVncChromiumStartReply rep; + + rfbSendChromiumStart(stuff->ipaddress, stuff->crServerPort, stuff->mothershipPort); + + REQUEST_SIZE_MATCH(xVncChromiumStartReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + } + (void)WriteToClient(client, SIZEOF(xVncChromiumStartReply), + (char *)&rep); + return (client->noClientException); +} /* ProcVncChromiumStart */ + +static int +ProcVncChromiumMonitor(ClientPtr client) +{ + REQUEST(xVncChromiumMonitorReq); + xVncChromiumMonitorReply rep; + + rfbChromiumMonitorWindowID(stuff->cr_windowid, stuff->windowid); + + REQUEST_SIZE_MATCH(xVncChromiumMonitorReq); + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + if(client->swapped) + { + register char n; + swaps(&rep.sequenceNumber, n); + } + (void)WriteToClient(client, SIZEOF(xVncChromiumMonitorReply), + (char *)&rep); + return (client->noClientException); +} /* ProcVncChromiumMonitor */ +#endif /* CHROMIUM */ + +static int +ProcVncDispatch(ClientPtr client) +{ + REQUEST(xReq); + + switch (stuff->data) + { + case X_VncQueryVersion: + return ProcVncQueryVersion(client); + case X_VncSelectNotify: + return ProcVncSelectNotify(client); + case X_VncConnection: + return ProcVncConnection(client); + case X_VncListConnections: + return ProcVncListConnections(client); +#ifdef CHROMIUM + case X_VncChromiumStart: + return ProcVncChromiumStart(client); + case X_VncChromiumMonitor: + return ProcVncChromiumMonitor(client); +#endif + default: + return BadRequest; + } +} /* ProcVncDispatch */ + +static int +SProcVncQueryVersion(ClientPtr client) +{ + REQUEST(xVncQueryVersionReq); + register char n; + + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xVncQueryVersionReq); + swaps(&stuff->majorVersion, n); + swaps(&stuff->minorVersion,n); + return ProcVncQueryVersion(client); +} /* SProcVncQueryVersion */ + +static int +SProcVncSelectNotify(ClientPtr client) +{ + REQUEST(xVncSelectNotifyReq); + register char n; + + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xVncSelectNotifyReq); + return ProcVncSelectNotify(client); +} /* SProcVncSelectNotify */ + +static int +SProcVncListConnections(ClientPtr client) +{ + REQUEST(xVncListConnectionsReq); + register char n; + + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xVncListConnectionsReq); + return ProcVncListConnections(client); +} /* SProcVncListConnections */ + +#ifdef CHROMIUM +static int +SProcVncChromiumStart(ClientPtr client) +{ + REQUEST(xVncChromiumStartReq); + register char n; + + swaps(&stuff->ipaddress, n); + swaps(&stuff->crServerPort, n); + swaps(&stuff->mothershipPort, n); + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xVncChromiumStartReq); + return ProcVncChromiumStart(client); +} /* SProcVncChromiumStart */ + +static int +SProcVncChromiumMonitor(ClientPtr client) +{ + REQUEST(xVncChromiumMonitorReq); + register char n; + + swaps(&stuff->length, n); + swaps(&stuff->windowid, n); + swaps(&stuff->cr_windowid, n); + REQUEST_SIZE_MATCH(xVncChromiumMonitorReq); + return ProcVncChromiumMonitor(client); +} /* SProcVncChromiumMonitor */ +#endif /* CHROMIUM */ + +static int +SProcVncConnection(ClientPtr client) +{ + REQUEST(xVncConnectionReq); + register char n; + + + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xVncConnectionReq); + swaps(&stuff->sock, n); + swaps(&stuff->accept,n); + return ProcVncConnection(client); +} /* SProcVncConnection */ + +static int +SProcVncDispatch(ClientPtr client) +{ + REQUEST(xReq); + + switch (stuff->data) + { + case X_VncQueryVersion: + return SProcVncQueryVersion(client); + case X_VncSelectNotify: + return SProcVncSelectNotify(client); + case X_VncConnection: + return SProcVncConnection(client); + case X_VncListConnections: + return SProcVncListConnections(client); +#ifdef CHROMIUM + case X_VncChromiumStart: + return SProcVncChromiumStart(client); + case X_VncChromiumMonitor: + return SProcVncChromiumMonitor(client); +#endif + default: + return BadRequest; + } +} /* SProcVncDispatch */ + +static void +SwapVncConnectedEvent(xVncConnectedEvent *from, xVncConnectedEvent *to) +{ + to->type = from->type; + to->detail = from->detail; + cpswaps(from->sequenceNumber, to->sequenceNumber); + cpswapl(from->connected, to->connected); +} + +#ifdef CHROMIUM +static void +SwapVncChromiumConnectedEvent(xVncConnectedEvent *from, xVncConnectedEvent *to) +{ + to->type = from->type; + to->detail = from->detail; + cpswaps(from->sequenceNumber, to->sequenceNumber); + cpswapl(from->connected, to->connected); +} +#endif + +static void +SwapVncDisconnectedEvent(xVncConnectedEvent *from, xVncConnectedEvent *to) +{ + to->type = from->type; + to->detail = from->detail; + cpswaps(from->sequenceNumber, to->sequenceNumber); + cpswapl(from->connected, to->connected); +} + +int +GenerateVncConnectedEvent(int sock) +{ +#if USE_ORIG_RES_CODE + VncNotifyListPtr pn; + + pn = (VncNotifyListPtr)LookupIDByType(faked, VncNotifyList); +#else + VncClientRecPtr pn = ClientsList; +#endif + + while (pn) + { + if (pn->client) + { + xVncConnectedEvent conn; + SOCKLEN_T peer_len; + struct sockaddr_in peer; + + conn.type = VncEventBase + XVncConnected; + conn.sequenceNumber = pn->client->sequence; + conn.connected = sock; + + peer_len = sizeof(peer); + if (getpeername(sock, (struct sockaddr *) &peer, &peer_len) == -1) + conn.ipaddress = 0; + else + conn.ipaddress = (CARD32)peer.sin_addr.s_addr; + + (void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask, + NoEventMask, NullGrab); + } + pn = pn->next; + } + + return 1; +} + + + +#ifdef CHROMIUM +int +GenerateVncChromiumConnectedEvent(int sock) +{ +#if USE_ORIG_RES_CODE + VncNotifyListPtr pn; + pn = (VncNotifyListPtr)LookupIDByType(faked, VncNotifyList); +#else + VncClientRecPtr pn = ClientsList; +#endif + rfbLog("Enter GenerateVncChromiumConnectedEvent\n"); + while (pn) + { + if (pn->client) + { + xVncConnectedEvent conn; + SOCKLEN_T peer_len; + struct sockaddr_in peer; + + rfbLog("Sending XVncChromiumConnected to client %p\n", + (void *) pn->client); + + conn.type = VncEventBase + XVncChromiumConnected; + conn.sequenceNumber = pn->client->sequence; + conn.connected = sock; + + peer_len = sizeof(peer); + if (getpeername(sock, (struct sockaddr *)&peer, &peer_len) == -1) + conn.ipaddress = 0; + else + conn.ipaddress = (CARD32)peer.sin_addr.s_addr; + + (void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask, + NoEventMask, NullGrab); + } + pn = pn->next; + } + return 1; +} +#endif /* CHROMIUM */ + + +int +GenerateVncDisconnectedEvent(int sock) +{ +#if USE_ORIG_RES_CODE + VncNotifyListPtr pn; + + pn = (VncNotifyListPtr)LookupIDByType(faked, VncNotifyList); +#else + VncClientRecPtr pn = ClientsList; +#endif + rfbLog("GenerateVncDisconnectedEvent\n"); + while (pn) + { + if (pn->client) + { + xVncDisconnectedEvent conn; + conn.type = VncEventBase + XVncDisconnected; + conn.sequenceNumber = pn->client->sequence; + conn.connected = sock; + (void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask, + NoEventMask, NullGrab); + } + pn = pn->next; + } + + return 1; +} + +static void +VncResetProc(ExtensionEntry *extEntry) +{ +} /* VncResetProc */ + + + +/** + * When the app calls libVnc's XVncSelectNotify() we wind up here. + * Either add or remove 'client' from the VncNotifyList depending on 'onoff'. + */ +int +VncSelectNotify(ClientPtr client, BOOL onoff) +{ +#if USE_ORIG_RES_CODE + VncNotifyListPtr head, newRec, tmp, freeRec = NULL; + + rfbLog("%s client %p onoff=%d\n", __func__, (void *) client, (int) onoff); + if (!faked) + faked = FakeClientID(client->index); +#else + /* ignore onoff param */ + VncSaveClientRecord(client); +#endif + +#if USE_ORIG_RES_CODE + /* Get the first VncNotifyListPtr */ + head = (VncNotifyListPtr) LookupIDByType(faked, VncNotifyList); + + /* search list for this client */ + tmp = head; + while (tmp) { + if (tmp->client == client) { + /* found client! */ + if (!onoff) + tmp->client = NULL; + return Success; + } + if (!tmp->client) + freeRec = tmp; /* save ptr to free record */ + tmp = tmp->next; + } + + /* if we get here, we didn't find client in the list */ + + if (!onoff) { + /* if turning off non-existing client, just return */ + return Success; + } + + /* OK, add new client to list now */ + + if (freeRec) { + /* re-using a free spot */ + freeRec->client = client; + return Success; + } + + /* need to allocate new node */ + if (!(newRec = (VncNotifyListPtr)xalloc(sizeof(VncNotifyListRec)))) + return BadAlloc; + /* insert at head, just as AddResource() does!!! */ + newRec->next = head; + newRec->client = client; + if (!AddResource(faked, VncNotifyList, newRec)) { + xfree(newRec); + return BadAlloc; + } +#endif + return Success; +} + + +#if USE_ORIG_RES_CODE +static int +VncDestroyNotifyList(pointer pn, XID id) +{ + VncNotifyListPtr cpn = (VncNotifyListPtr) pn; + rfbLog("%s client %p\n", __func__, (void *) cpn->client); + cpn->client = NULL; + return Success; +} +#endif + +static Bool +CreateResourceTypes(void) +{ +#if USE_ORIG_RES_CODE + if (VncResourceGeneration == serverGeneration) + return TRUE; + + VncResourceGeneration = serverGeneration; + + if (!(VncNotifyList = CreateNewResourceType(VncDestroyNotifyList))) { + ErrorF("CreateResourceTypes: failed to allocate vnc notify list resource.\n"); + return FALSE; + } +#endif + return TRUE; +} + + + +#if XFREE86VNC +static unsigned long vncCreateScreenResourcesIndex; +static unsigned long vncExtGeneration = 0; +extern Bool VNCInit(ScreenPtr pScreen, unsigned char *FBStart); + +/* copied from miscrinit.c */ +typedef struct +{ + pointer pbits; /* pointer to framebuffer */ + int width; /* delta to add to a framebuffer addr to move one row down */ +} miScreenInitParmsRec, *miScreenInitParmsPtr; + + +static Bool +vncCreateScreenResources(ScreenPtr pScreen) +{ + int ret = TRUE; + CreateScreenResourcesProcPtr CreateScreenResources = + (CreateScreenResourcesProcPtr) + pScreen->devPrivates[vncCreateScreenResourcesIndex].ptr; + miScreenInitParmsPtr pScrInitParms; + + pScrInitParms = (miScreenInitParmsPtr)pScreen->devPrivate; + + if ( pScreen->CreateScreenResources != vncCreateScreenResources ) { + /* Can't find hook we are hung on */ + xf86DrvMsg(pScreen->myNum, X_WARNING /* X_ERROR */, + "vncCreateScreenResources %p called when not in " + "pScreen->CreateScreenResources %p n", + (void *) vncCreateScreenResources, + (void *) pScreen->CreateScreenResources ); + } + + /* Now do our stuff */ + VNCInit(pScreen, pScrInitParms->pbits); + + /* Unhook this function ... */ + pScreen->CreateScreenResources = CreateScreenResources; + pScreen->devPrivates[vncCreateScreenResourcesIndex].ptr = NULL; + + /* ... and call the previous CreateScreenResources fuction, if any */ + if (pScreen->CreateScreenResources) { + ret = (*pScreen->CreateScreenResources)(pScreen); + } + +#ifdef DEBUG + ErrorF("vncCreateScreenResources() returns %d\n", ret); +#endif + return ret; +} +#endif + + + +void +VncExtensionInit(void) +{ + ExtensionEntry *extEntry; + +#if XFREE86VNC + if (vncExtGeneration != serverGeneration) { + unsigned int i; + + vncExtGeneration = serverGeneration; + + if ( ((vncCreateScreenResourcesIndex = AllocateScreenPrivateIndex()) < 0) || + ((vncScreenPrivateIndex = AllocateScreenPrivateIndex()) < 0) || + ((rfbGCIndex = AllocateGCPrivateIndex()) < 0) ) + return; + + for (i = 0 ; i < screenInfo.numScreens; i++) + { + screenInfo.screens[i]->devPrivates[vncCreateScreenResourcesIndex].ptr + = (void*)(xf86Screens[i]->pScreen->CreateScreenResources); + xf86Screens[i]->pScreen->CreateScreenResources = vncCreateScreenResources; + } + + gethostname(rfbThisHost, 255); + } +#endif + + if (!CreateResourceTypes()) + return; + + extEntry = AddExtension(VNC_EXTENSION_NAME, + XVncNumberEvents, XVncNumberErrors, + ProcVncDispatch, SProcVncDispatch, + VncResetProc, StandardMinorOpcode); + + VncErrorBase = extEntry->errorBase; + VncEventBase = extEntry->eventBase; + + EventSwapVector[VncEventBase + XVncConnected] = + (EventSwapPtr)SwapVncConnectedEvent; + EventSwapVector[VncEventBase + XVncDisconnected] = + (EventSwapPtr)SwapVncDisconnectedEvent; +#ifdef CHROMIUM + EventSwapVector[VncEventBase + XVncChromiumConnected] = + (EventSwapPtr)SwapVncChromiumConnectedEvent; +#endif +} /* VncExtensionInit */ diff -pNur xorg-server-1.4.orig/hw/vnc/xistubs.c xorg-server-1.4/hw/vnc/xistubs.c --- xorg-server-1.4.orig/hw/vnc/xistubs.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/xistubs.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,323 @@ +/* $Xorg: stubs.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */ + +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 +OPEN GROUP 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 Open Group 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 Open Group. + +Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Hewlett-Packard not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +********************************************************/ +/* $XFree86: xc/programs/Xserver/Xi/stubs.c,v 3.3 2001/01/17 22:13:26 dawes Exp $ */ + +/* + * stubs.c -- stub routines for the X server side of the XINPUT + * extension. This file is mainly to be used only as documentation. + * There is not much code here, and you can't get a working XINPUT + * server just using this. + * The Xvfb server uses this file so it will compile with the same + * object files as the real X server for a platform that has XINPUT. + * Xnest could do the same thing. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#define NEED_EVENTS +#include <X11/X.h> +#include <X11/Xproto.h> +#include <X11/extensions/XI.h> +#include <X11/extensions/XIproto.h> +#include "inputstr.h" +#include "XIstubs.h" + +/*********************************************************************** + * + * Caller: ProcXChangeKeyboardDevice + * + * This procedure does the implementation-dependent portion of the work + * needed to change the keyboard device. + * + * The X keyboard device has a FocusRec. If the device that has been + * made into the new X keyboard did not have a FocusRec, + * ProcXChangeKeyboardDevice will allocate one for it. + * + * If you do not want clients to be able to focus the old X keyboard + * device, call DeleteFocusClassDeviceStruct to free the FocusRec. + * + * If you support input devices with keys that you do not want to be + * used as the X keyboard, you need to check for them here and return + * a BadDevice error. + * + * The default implementation is to do nothing (assume you do want + * clients to be able to focus the old X keyboard). The commented-out + * sample code shows what you might do if you don't want the default. + * + */ + +int +ChangeKeyboardDevice (old_dev, new_dev) + DeviceIntPtr old_dev; + DeviceIntPtr new_dev; + { + /*********************************************************************** + DeleteFocusClassDeviceStruct(old_dev); * defined in xchgptr.c * + **********************************************************************/ + return BadMatch; + } + + +/*********************************************************************** + * + * Caller: ProcXChangePointerDevice + * + * This procedure does the implementation-dependent portion of the work + * needed to change the pointer device. + * + * The X pointer device does not have a FocusRec. If the device that + * has been made into the new X pointer had a FocusRec, + * ProcXChangePointerDevice will free it. + * + * If you want clients to be able to focus the old pointer device that + * has now become accessible through the input extension, you need to + * add a FocusRec to it here. + * + * The XChangePointerDevice protocol request also allows the client + * to choose which axes of the new pointer device are used to move + * the X cursor in the X- and Y- directions. If the axes are different + * than the default ones, you need to keep track of that here. + * + * If you support input devices with valuators that you do not want to be + * used as the X pointer, you need to check for them here and return a + * BadDevice error. + * + * The default implementation is to do nothing (assume you don't want + * clients to be able to focus the old X pointer). The commented-out + * sample code shows what you might do if you don't want the default. + * + */ + +int +#if NeedFunctionPrototypes +ChangePointerDevice ( + DeviceIntPtr old_dev, + DeviceIntPtr new_dev, + unsigned char x, + unsigned char y) +#else +ChangePointerDevice (old_dev, new_dev, x, y) + DeviceIntPtr old_dev, new_dev; + unsigned char x, y; +#endif + { + /*********************************************************************** + InitFocusClassDeviceStruct(old_dev); * allow focusing old ptr* + + x_axis = x; * keep track of new x-axis* + y_axis = y; * keep track of new y-axis* + if (x_axis != 0 || y_axis != 1) + axes_changed = TRUE; * remember axes have changed* + else + axes_changed = FALSE; + *************************************************************************/ + return BadMatch; + } + +/*********************************************************************** + * + * Caller: ProcXCloseDevice + * + * Take care of implementation-dependent details of closing a device. + * Some implementations may actually close the device, others may just + * remove this clients interest in that device. + * + * The default implementation is to do nothing (assume all input devices + * are initialized during X server initialization and kept open). + * + */ + +void +CloseInputDevice (d, client) + DeviceIntPtr d; + ClientPtr client; + { + } + +/*********************************************************************** + * + * Caller: ProcXListInputDevices + * + * This is the implementation-dependent routine to initialize an input + * device to the point that information about it can be listed. + * Some implementations open all input devices when the server is first + * initialized, and never close them. Other implementations open only + * the X pointer and keyboard devices during server initialization, + * and only open other input devices when some client makes an + * XOpenDevice request. If some other process has the device open, the + * server may not be able to get information about the device to list it. + * + * This procedure should be used by implementations that do not initialize + * all input devices at server startup. It should do device-dependent + * initialization for any devices not previously initialized, and call + * AddInputDevice for each of those devices so that a DeviceIntRec will be + * created for them. + * + * The default implementation is to do nothing (assume all input devices + * are initialized during X server initialization and kept open). + * The commented-out sample code shows what you might do if you don't want + * the default. + * + */ + +void +AddOtherInputDevices () + { + /********************************************************************** + for each uninitialized device, do something like: + + DeviceIntPtr dev; + DeviceProc deviceProc; + pointer private; + + dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE); + dev->public.devicePrivate = private; + RegisterOtherDevice(dev); + dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success); + ************************************************************************/ + + } + +/*********************************************************************** + * + * Caller: ProcXOpenDevice + * + * This is the implementation-dependent routine to open an input device. + * Some implementations open all input devices when the server is first + * initialized, and never close them. Other implementations open only + * the X pointer and keyboard devices during server initialization, + * and only open other input devices when some client makes an + * XOpenDevice request. This entry point is for the latter type of + * implementation. + * + * If the physical device is not already open, do it here. In this case, + * you need to keep track of the fact that one or more clients has the + * device open, and physically close it when the last client that has + * it open does an XCloseDevice. + * + * The default implementation is to do nothing (assume all input devices + * are opened during X server initialization and kept open). + * + */ + +void +OpenInputDevice (dev, client, status) + DeviceIntPtr dev; + ClientPtr client; + int *status; + { + } + +/**************************************************************************** + * + * Caller: ProcXSetDeviceMode + * + * Change the mode of an extension device. + * This function is used to change the mode of a device from reporting + * relative motion to reporting absolute positional information, and + * vice versa. + * The default implementation below is that no such devices are supported. + * + */ + +int +SetDeviceMode (client, dev, mode) + register ClientPtr client; + DeviceIntPtr dev; + int mode; + { + return BadMatch; + } + +/**************************************************************************** + * + * Caller: ProcXSetDeviceValuators + * + * Set the value of valuators on an extension input device. + * This function is used to set the initial value of valuators on + * those input devices that are capable of reporting either relative + * motion or an absolute position, and allow an initial position to be set. + * The default implementation below is that no such devices are supported. + * + */ + +int +SetDeviceValuators (client, dev, valuators, first_valuator, num_valuators) + register ClientPtr client; + DeviceIntPtr dev; + int *valuators; + int first_valuator; + int num_valuators; + { + return BadMatch; + } + +/**************************************************************************** + * + * Caller: ProcXChangeDeviceControl + * + * Change the specified device controls on an extension input device. + * + */ + +int +ChangeDeviceControl (client, dev, control) + register ClientPtr client; + DeviceIntPtr dev; + xDeviceCtl *control; + { + switch (control->control) + { + case DEVICE_RESOLUTION: + return (BadMatch); + default: + return (BadMatch); + } + } diff -pNur xorg-server-1.4.orig/hw/vnc/zlib.c xorg-server-1.4/hw/vnc/zlib.c --- xorg-server-1.4.orig/hw/vnc/zlib.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/vnc/zlib.c 2007-09-06 16:09:45.000000000 -0700 @@ -0,0 +1,310 @@ +/* + * zlib.c + * + * Routines to implement zlib based encoding (deflate). + * + * Modified for XFree86 4.x by Alan Hourihane <alanh@fairlite.demon.co.uk> + */ + +/* + * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + * + * For the latest source code, please check: + * + * http://www.developVNC.org/ + * + * or send email to feedback@developvnc.org. + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + + +#include <stdio.h> +#include "rfb.h" + +/* + * zlibBeforeBuf contains pixel data in the client's format. + * zlibAfterBuf contains the zlib (deflated) encoding version. + * If the zlib compressed/encoded version is + * larger than the raw data or if it exceeds zlibAfterBufSize then + * raw encoding is used instead. + */ + +static int zlibBeforeBufSize = 0; +static unsigned char *zlibBeforeBuf = NULL; + +static int zlibAfterBufSize = 0; +static unsigned char *zlibAfterBuf = NULL; +static int zlibAfterBufLen; + +/* + * rfbSendOneRectEncodingZlib - send a given rectangle using one Zlib + * rectangle encoding. + */ + +Bool +rfbSendOneRectEncodingZlib(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + rfbFramebufferUpdateRectHeader rect; + rfbZlibHeader hdr; + int deflateResult; + int previousOut; + int i; + int maxRawSize; + int maxCompSize; + + maxRawSize = (pVNC->width * pVNC->height + * (cl->format.bitsPerPixel / 8)); + + if (zlibBeforeBufSize < maxRawSize) { + zlibBeforeBufSize = maxRawSize; + if (zlibBeforeBuf == NULL) + zlibBeforeBuf = (unsigned char *)xalloc(zlibBeforeBufSize); + else + zlibBeforeBuf = (unsigned char *)xrealloc(zlibBeforeBuf, zlibBeforeBufSize); + } + + /* zlib compression is not useful for very small data sets. + * So, we just send these raw without any compression. + */ + if (( w * h * (pVNC->bitsPerPixel / 8)) < + VNC_ENCODE_ZLIB_MIN_COMP_SIZE ) { + + int result; + + /* The translation function (used also by the in raw encoding) + * requires 4/2/1 byte alignment in the output buffer (which is + * pVNC->updateBuf for the raw encoding) based on the bitsPerPixel of + * the viewer/client. This prevents SIGBUS errors on some + * architectures like SPARC, PARISC... + */ + if (( cl->format.bitsPerPixel > 8 ) && + ( pVNC->ublen % ( cl->format.bitsPerPixel / 8 )) != 0 ) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + result = rfbSendRectEncodingRaw(cl, x, y, w, h); + + return result; + + } + + /* + * zlib requires output buffer to be slightly larger than the input + * buffer, in the worst case. + */ + maxCompSize = maxRawSize + (( maxRawSize + 99 ) / 100 ) + 12; + + if (zlibAfterBufSize < maxCompSize) { + zlibAfterBufSize = maxCompSize; + if (zlibAfterBuf == NULL) + zlibAfterBuf = (unsigned char *)xalloc(zlibAfterBufSize); + else + zlibAfterBuf = (unsigned char *)xrealloc(zlibAfterBuf, zlibAfterBufSize); + } + + /* + * Convert pixel data to client format. + */ + (*cl->translateFn)(cl->pScreen, cl->translateLookupTable, + &pVNC->rfbServerFormat, + &cl->format, zlibBeforeBuf, + pVNC->paddedWidthInBytes, w, h, x, y); + + cl->compStream.next_in = ( Bytef * )zlibBeforeBuf; + cl->compStream.avail_in = w * h * (cl->format.bitsPerPixel / 8); + cl->compStream.next_out = ( Bytef * )zlibAfterBuf; + cl->compStream.avail_out = maxCompSize; + cl->compStream.data_type = Z_BINARY; + + /* Initialize the deflation state. */ + if ( cl->compStreamInited == FALSE ) { + + cl->compStream.total_in = 0; + cl->compStream.total_out = 0; + cl->compStream.zalloc = Z_NULL; + cl->compStream.zfree = Z_NULL; + cl->compStream.opaque = Z_NULL; + + deflateInit2( &(cl->compStream), + cl->zlibCompressLevel, + Z_DEFLATED, + MAX_WBITS, + MAX_MEM_LEVEL, + Z_DEFAULT_STRATEGY ); + /* deflateInit( &(cl->compStream), Z_BEST_COMPRESSION ); */ + /* deflateInit( &(cl->compStream), Z_BEST_SPEED ); */ + cl->compStreamInited = TRUE; + + } + + previousOut = cl->compStream.total_out; + + /* Perform the compression here. */ + deflateResult = deflate( &(cl->compStream), Z_SYNC_FLUSH ); + + /* Find the total size of the resulting compressed data. */ + zlibAfterBufLen = cl->compStream.total_out - previousOut; + + if ( deflateResult != Z_OK ) { + rfbLog("zlib deflation error: %s\n", cl->compStream.msg); + return FALSE; + } + + /* Note that it is not possible to switch zlib parameters based on + * the results of the compression pass. The reason is + * that we rely on the compressor and decompressor states being + * in sync. Compressing and then discarding the results would + * cause lose of synchronization. + */ + + /* Update statics */ + cl->rfbRectanglesSent[rfbEncodingZlib]++; + cl->rfbBytesSent[rfbEncodingZlib] += (sz_rfbFramebufferUpdateRectHeader + + sz_rfbZlibHeader + zlibAfterBufLen); + + if (pVNC->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbZlibHeader + > UPDATE_BUF_SIZE) + { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + + rect.r.x = Swap16IfLE(x); + rect.r.y = Swap16IfLE(y); + rect.r.w = Swap16IfLE(w); + rect.r.h = Swap16IfLE(h); + rect.encoding = Swap32IfLE(rfbEncodingZlib); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&rect, + sz_rfbFramebufferUpdateRectHeader); + pVNC->ublen += sz_rfbFramebufferUpdateRectHeader; + + hdr.nBytes = Swap32IfLE(zlibAfterBufLen); + + memcpy(&pVNC->updateBuf[pVNC->ublen], (char *)&hdr, sz_rfbZlibHeader); + pVNC->ublen += sz_rfbZlibHeader; + + for (i = 0; i < zlibAfterBufLen;) { + + int bytesToCopy = UPDATE_BUF_SIZE - pVNC->ublen; + + if (i + bytesToCopy > zlibAfterBufLen) { + bytesToCopy = zlibAfterBufLen - i; + } + + memcpy(&pVNC->updateBuf[pVNC->ublen], &zlibAfterBuf[i], bytesToCopy); + + pVNC->ublen += bytesToCopy; + i += bytesToCopy; + + if (pVNC->ublen == UPDATE_BUF_SIZE) { + if (!rfbSendUpdateBuf(cl)) + return FALSE; + } + } + + return TRUE; + +} + + +/* + * rfbSendRectEncodingZlib - send a given rectangle using one or more + * Zlib encoding rectangles. + */ + +Bool +rfbSendRectEncodingZlib(cl, x, y, w, h) + rfbClientPtr cl; + int x, y, w, h; +{ + VNCSCREENPTR(cl->pScreen); + int maxLines; + int linesRemaining; + rfbRectangle partialRect; + + partialRect.x = x; + partialRect.y = y; + partialRect.w = w; + partialRect.h = h; + + /* Determine maximum pixel/scan lines allowed per rectangle. */ + maxLines = ( ZLIB_MAX_SIZE(w) / w ); + + /* Initialize number of scan lines left to do. */ + linesRemaining = h; + + /* Loop until all work is done. */ + while ( linesRemaining > 0 ) { + + int linesToComp; + + if ( maxLines < linesRemaining ) + linesToComp = maxLines; + else + linesToComp = linesRemaining; + + partialRect.h = linesToComp; + + /* Encode (compress) and send the next rectangle. */ + if ( ! rfbSendOneRectEncodingZlib( cl, + partialRect.x, + partialRect.y, + partialRect.w, + partialRect.h )) { + + return FALSE; + } + + /* Technically, flushing the buffer here is not extrememly + * efficient. However, this improves the overall throughput + * of the system over very slow networks. By flushing + * the buffer with every maximum size zlib rectangle, we + * improve the pipelining usage of the server CPU, network, + * and viewer CPU components. Insuring that these components + * are working in parallel actually improves the performance + * seen by the user. + * Since, zlib is most useful for slow networks, this flush + * is appropriate for the desired behavior of the zlib encoding. + */ + if (( pVNC->ublen > 0 ) && + ( linesToComp == maxLines )) { + if (!rfbSendUpdateBuf(cl)) { + + return FALSE; + } + } + + /* Update remaining and incremental rectangle location. */ + linesRemaining -= linesToComp; + partialRect.y += linesToComp; + + } + + return TRUE; + +} + + diff -pNur xorg-server-1.4.orig/hw/xfree86/dixmods/Makefile.am xorg-server-1.4/hw/xfree86/dixmods/Makefile.am --- xorg-server-1.4.orig/hw/xfree86/dixmods/Makefile.am 2007-08-23 12:05:48.000000000 -0700 +++ xorg-server-1.4/hw/xfree86/dixmods/Makefile.am 2007-09-06 16:09:46.000000000 -0700 @@ -14,6 +14,10 @@ if DBE DBEMOD = libdbe.la endif +if XCLIPLIST +XCLIPLISTMOD = libxcliplist.la +endif + if AFB AFBMOD = libafb.la endif @@ -36,6 +40,7 @@ module_LTLIBRARIES = $(AFBMOD) \ extsmoduledir = $(moduledir)/extensions extsmodule_LTLIBRARIES = librecord.la \ $(DBEMOD) \ + $(XCLIPLISTMOD) \ $(GLXMODS) \ $(XTRAPMOD) @@ -46,6 +51,7 @@ fontsmodule_LTLIBRARIES = libfreetype.la AM_CFLAGS = @XORG_CFLAGS@ @DIX_CFLAGS@ INCLUDES = @XORG_INCS@ \ -I$(top_srcdir)/dbe \ + -I$(top_srcdir)/xcliplist \ -I$(top_srcdir)/hw/xfree86/loader \ -I$(top_srcdir)/miext/shadow \ -I$(top_srcdir)/GL/glx @@ -70,6 +76,10 @@ libdbe_la_LDFLAGS = -avoid-version libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la libdbe_la_SOURCES = dbemodule.c +libxcliplist_la_LDFLAGS = -avoid-version +libxcliplist_la_LIBADD = $(top_builddir)/xcliplist/libxcliplist.la +libxcliplist_la_SOURCES = $(top_srcdir)/xcliplist/cliplistmod.c + libfb_la_LDFLAGS = -avoid-version libfb_la_LIBADD = $(top_builddir)/fb/libfb.la libfb_la_SOURCES = $(top_builddir)/fb/fbcmap_mi.c fbmodule.c diff -pNur xorg-server-1.4.orig/hw/xfree86/vnc/Makefile.am xorg-server-1.4/hw/xfree86/vnc/Makefile.am --- xorg-server-1.4.orig/hw/xfree86/vnc/Makefile.am 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/xfree86/vnc/Makefile.am 2007-09-06 16:09:51.000000000 -0700 @@ -0,0 +1,53 @@ +libvnc_la_LTLIBRARIES = libvnc.la +libvnc_la_CFLAGS = -I$(top_srcdir)/hw/xfree86/common \ + -I$(top_srcdir)/hw/xfree86/os-support \ + -I$(top_srcdir)/hw/xfree86/os-support/bus \ + -I$(top_srcdir)/mi \ + -I$(top_srcdir)/render \ + -I$(top_srcdir)/GL/glx \ + -I$(top_srcdir)/GL/include \ + -I$(top_builddir)/GL/include \ + -I@MESA_SOURCE@/include \ + -DHAVE_XORG_CONFIG_H \ + -DXFree86LOADER \ + -DXFREE86VNC=1 \ + -DCHROMIUM=1 \ + @LIBDRM_CFLAGS@ \ + @GL_CFLAGS@ \ + @PIXMAN_CFLAGS@ + +# @MODULE_DEFINES@ +# @LOADER_DEFINES@ + +libvnc_la_LIBADD = -ljpeg -lcrypt +libvnc_la_LDFLAGS = -module -avoid-version +libvnc_ladir = $(moduledir)/extensions +libvnc_la_SOURCES = \ + 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 \ + vncInit.c \ + vncauth.c \ + vncext.c \ + zlib.c + +#sdk_HEADERS = vncint.h diff -pNur xorg-server-1.4.orig/hw/xfree86/vnc/README xorg-server-1.4/hw/xfree86/vnc/README --- xorg-server-1.4.orig/hw/xfree86/vnc/README 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/xfree86/vnc/README 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1 @@ +This directory contains the sources for building the vnc.so server extension module. diff -pNur xorg-server-1.4.orig/hw/xfree86/vnc/vncInit.c xorg-server-1.4/hw/xfree86/vnc/vncInit.c --- xorg-server-1.4.orig/hw/xfree86/vnc/vncInit.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/xfree86/vnc/vncInit.c 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1,638 @@ +/* + * 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> + */ +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include <netinet/in.h> +#include <time.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "../ramdac/xf86CursorPriv.h" +#include "rfb.h" +#include "vncint.h" + +#include "xf86.h" +#include "xf86_OSproc.h" +#include "xf86Resources.h" +#include "xf86Version.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); + +Bool VNCInit(ScreenPtr pScreen, unsigned char *FBStart); + +#ifndef XFree86LOADER +static unsigned long VNCGeneration = 0; +#endif +static const OptionInfoRec *VNCAvailableOptions(void *unused); +static void rfbWakeupHandler (int i, pointer blockData, unsigned long err, pointer pReadmask); + +static Bool vncCursorRealizeCursor(ScreenPtr, CursorPtr); +static Bool vncCursorUnrealizeCursor(ScreenPtr, CursorPtr); +static void vncCursorSetCursor(ScreenPtr, CursorPtr, int, int); +static void vncCursorMoveCursor(ScreenPtr, int, int); +static Bool vncDisplayCursor(ScreenPtr, CursorPtr); + +static miPointerSpriteFuncRec vncCursorSpriteFuncs = { + vncCursorRealizeCursor, + vncCursorUnrealizeCursor, + vncCursorSetCursor, + vncCursorMoveCursor +}; + +/* + * VNC Config options + */ + +typedef enum { + OPTION_USEVNC, + OPTION_RFBPORT, + OPTION_HTTPPORT, + OPTION_ALWAYS_SHARED, + OPTION_NEVER_SHARED, + OPTION_DONT_DISCONNECT, + OPTION_HTTPDIR, + OPTION_PASSWD_FILE, + OPTION_USER_ACCEPT, + OPTION_LOCALHOST, + OPTION_INTERFACE, + OPTION_VIEWONLY, + OPTION_LOGIN_AUTH, +} VNCOpts; + +static const OptionInfoRec VNCOptions[] = { + {OPTION_USEVNC, "usevnc", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_RFBPORT, "rfbport", OPTV_INTEGER, {0}, FALSE }, + {OPTION_HTTPPORT, "httpport", OPTV_INTEGER, {0}, FALSE }, + {OPTION_ALWAYS_SHARED, "alwaysshared", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_NEVER_SHARED, "nevershared", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_DONT_DISCONNECT, "dontdisconnect", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_HTTPDIR, "httpdir", OPTV_STRING, {0}, FALSE }, + {OPTION_PASSWD_FILE, "rfbauth", OPTV_STRING, {0}, FALSE }, + {OPTION_USER_ACCEPT, "useraccept", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_LOCALHOST, "localhost", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_INTERFACE, "interface", OPTV_STRING, {0}, FALSE }, + {OPTION_VIEWONLY, "viewonly", OPTV_BOOLEAN, {0}, FALSE }, + {OPTION_LOGIN_AUTH, "loginauth", OPTV_BOOLEAN, {0}, FALSE }, + { -1, NULL, OPTV_NONE, {0}, FALSE } +}; + +/*ARGSUSED*/ +static const OptionInfoRec * +VNCAvailableOptions(void *unused) +{ + return (VNCOptions); +} + +/* + * rfbLog prints a time-stamped message to the log file (stderr). + */ + +void rfbLog(char *format, ...) +{ + va_list ap; + char buf[256]; + time_t clock; + + time(&clock); + strftime(buf, 255, "%d/%m/%Y %H:%M:%S ", localtime(&clock)); + xf86DrvMsgVerb(-1, X_INFO, 1, buf); + + va_start(ap, format); + xf86VDrvMsgVerb(-1, X_NONE, 1, format, ap); + va_end(ap); +} + +void rfbLogPerror(char *str) +{ + rfbLog(""); + perror(str); +} + +/* + * Called by vncCreateScreenResources() + */ +Bool +VNCInit(ScreenPtr pScreen, unsigned char *FBStart) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + VisualPtr visual; + vncScreenPtr pScreenPriv; + OptionInfoPtr options; + char *interface_str = NULL; + miPointerScreenPtr PointPriv; + xf86CursorScreenPtr xf86CursorPriv; +#ifdef RENDER + PictureScreenPtr ps; +#endif + + if (!FBStart) + return FALSE; + +#ifndef XFree86LOADER + if (VNCGeneration != serverGeneration) { + VncExtensionInit(); + VNCGeneration = serverGeneration; + } +#endif + + if (!AllocateGCPrivate(pScreen, rfbGCIndex, sizeof(rfbGCRec))) + return FALSE; + + if (!(pScreenPriv = xalloc(sizeof(vncScreenRec)))) + return FALSE; + + pScreen->devPrivates[vncScreenPrivateIndex].ptr = (pointer)pScreenPriv; + + options = xnfalloc(sizeof(VNCOptions)); + (void)memcpy(options, VNCOptions, sizeof(VNCOptions)); + xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options); + + if (xf86ReturnOptValBool(options, OPTION_USEVNC, FALSE)) { + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "VNC enabled\n"); + } else { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VNC disabled\n"); + xfree(options); + return FALSE; + } + + 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; + xf86GetOptValInteger(options, OPTION_RFBPORT, &pScreenPriv->rfbPort); + pScreenPriv->httpPort = 0; + xf86GetOptValInteger(options, OPTION_HTTPPORT, &pScreenPriv->httpPort); + pScreenPriv->rfbAuthPasswdFile = + xf86GetOptValString(options, OPTION_PASSWD_FILE); + pScreenPriv->httpDir = + xf86GetOptValString(options, OPTION_HTTPDIR); + pScreenPriv->rfbAlwaysShared = FALSE; + xf86GetOptValBool(options, OPTION_ALWAYS_SHARED, + &pScreenPriv->rfbAlwaysShared); + pScreenPriv->rfbNeverShared = FALSE; + xf86GetOptValBool(options, OPTION_NEVER_SHARED, + &pScreenPriv->rfbNeverShared); + pScreenPriv->rfbUserAccept = FALSE; + xf86GetOptValBool(options, OPTION_USER_ACCEPT, + &pScreenPriv->rfbUserAccept); + pScreenPriv->rfbViewOnly = FALSE; + xf86GetOptValBool(options, OPTION_VIEWONLY, + &pScreenPriv->rfbViewOnly); + pScreenPriv->rfbDontDisconnect = FALSE; + xf86GetOptValBool(options, OPTION_DONT_DISCONNECT, + &pScreenPriv->rfbDontDisconnect); + pScreenPriv->loginAuthEnabled = FALSE; + xf86GetOptValBool(options, OPTION_LOGIN_AUTH, + &pScreenPriv->loginAuthEnabled); + + 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"); + } + + xfree(options); + + 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->virtualX; + pScreenPriv->height = pScrn->virtualY; + pScreenPriv->depth = pScrn->depth; + pScreenPriv->paddedWidthInBytes = PixmapBytePad(pScrn->displayWidth, pScrn->depth); + pScreenPriv->bitsPerPixel = rfbBitsPerPixel(pScrn->depth); + pScreenPriv->pfbMemory = FBStart; + pScreenPriv->oldpfbMemory = FBStart; + + 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->EnableDisableFBAccess = pScrn->EnableDisableFBAccess; + pScreenPriv->InstallColormap = pScreen->InstallColormap; + pScreenPriv->UninstallColormap = pScreen->UninstallColormap; + pScreenPriv->ListInstalledColormaps = pScreen->ListInstalledColormaps; + pScreenPriv->StoreColors = pScreen->StoreColors; + pScreenPriv->DisplayCursor = pScreen->DisplayCursor; +#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; + pScrn->EnableDisableFBAccess = rfbEnableDisableFBAccess; + pScreen->InstallColormap = rfbInstallColormap; + pScreen->UninstallColormap = rfbUninstallColormap; + pScreen->ListInstalledColormaps = rfbListInstalledColormaps; + pScreen->StoreColors = rfbStoreColors; + pScreen->DisplayCursor = vncDisplayCursor; /* it's defined in here */ + +#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->bitsPerPixel; + pScreenPriv->rfbServerFormat.depth = pScrn->depth; + 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; + } + + PointPriv = pScreen->devPrivates[miPointerScreenIndex].ptr; + + pScreenPriv->spriteFuncs = PointPriv->spriteFuncs; + PointPriv->spriteFuncs = &vncCursorSpriteFuncs; + + if (xf86LoaderCheckSymbol("xf86CursorScreenIndex")) { + int *si; + + si = LoaderSymbol("xf86CursorScreenIndex"); + + if (*si != -1) { + xf86CursorPriv = pScreen->devPrivates[*si].ptr; + + if (xf86CursorPriv) { + pScreenPriv->UseHWCursor = xf86CursorPriv->CursorInfoPtr->UseHWCursor; + xf86CursorPriv->CursorInfoPtr->UseHWCursor = vncUseHWCursor; +#ifdef ARGB_CURSOR + pScreenPriv->UseHWCursorARGB = xf86CursorPriv->CursorInfoPtr->UseHWCursorARGB; + xf86CursorPriv->CursorInfoPtr->UseHWCursorARGB = vncUseHWCursorARGB; +#endif + pScreenPriv->SWCursor = &xf86CursorPriv->SWCursor; + } + } + } + + return TRUE; +} + +/****** miPointerSpriteFunctions *******/ + +static Bool +vncCursorRealizeCursor(ScreenPtr pScreen, CursorPtr pCurs) +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + + return (*pScreenPriv->spriteFuncs->RealizeCursor)(pScreen, pCurs); +} + +static Bool +vncCursorUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCurs) +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + + return (*pScreenPriv->spriteFuncs->UnrealizeCursor)(pScreen, pCurs); +} + +static void +vncCursorSetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y) +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + + pScreenPriv->pCurs = pCurs; + + /* Without this call, cursor changes only appear in the viewer when + * some other drawing has occured. Added by BrianP. + */ + rfbScheduleUpdate(pScreen); + +#if 0 + if (pCurs == NullCursor) { /* means we're supposed to remove the cursor */ + if (pScreenPriv->cursorIsDrawn) + pScreenPriv->cursorIsDrawn = FALSE; + return; + } + + pScreenPriv->cursorIsDrawn = TRUE; +#endif + + (*pScreenPriv->spriteFuncs->SetCursor)(pScreen, pCurs, x, y); +} + +static void +vncCursorMoveCursor(ScreenPtr pScreen, int x, int y) +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + rfbClientPtr cl; + + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (cl->enableCursorPosUpdates) + cl->cursorWasMoved = TRUE; + } + + (*pScreenPriv->spriteFuncs->MoveCursor)(pScreen, x, y); +} + +Bool +vncUseHWCursor(pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + rfbClientPtr cl; + + if (!*pScreenPriv->UseHWCursor) { + /* If the driver doesn't have a UseHWCursor function we're + * basically saying we can have the HWCursor on all the time + */ + pScreenPriv->SWCursor = (Bool *)FALSE; + return TRUE; + } + + pScreenPriv->SWCursor = (Bool *)FALSE; + + /* If someone's connected, we revert to software cursor */ + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (!cl->enableCursorShapeUpdates) + pScreenPriv->SWCursor = (Bool *)TRUE; + } + + if (pScreenPriv->SWCursor == (Bool *)TRUE) + return FALSE; + + return (*pScreenPriv->UseHWCursor)(pScreen, pCursor); +} + +#ifdef ARGB_CURSOR +#include "cursorstr.h" + +Bool +vncUseHWCursorARGB(pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + rfbClientPtr cl; + + if (!*pScreenPriv->UseHWCursorARGB) { + pScreenPriv->SWCursor = (Bool *)TRUE; + return FALSE; + } + + pScreenPriv->SWCursor = (Bool *)FALSE; + + /* If someone's connected, we revert to software cursor */ + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (!cl->enableCursorShapeUpdates) + pScreenPriv->SWCursor = (Bool *)TRUE; + } + + if (pScreenPriv->SWCursor == (Bool *)TRUE) + return FALSE; + + return (*pScreenPriv->UseHWCursorARGB)(pScreen, pCursor); +} +#endif + +static Bool +vncDisplayCursor(pScreen, pCursor) + ScreenPtr pScreen; + CursorPtr pCursor; +{ + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + rfbClientPtr cl; + Bool ret; + + pScreen->DisplayCursor = pScreenPriv->DisplayCursor; + + for (cl = rfbClientHead; cl ; cl = cl->next) { + if (cl->enableCursorShapeUpdates) + cl->cursorWasChanged = TRUE; + } + + ret = (*pScreen->DisplayCursor)(pScreen, pCursor); + + pScreen->DisplayCursor = vncDisplayCursor; + + return ret; +} + +static void +rfbWakeupHandler ( + int i, + pointer blockData, + unsigned long err, + pointer pReadmask +){ + ScreenPtr pScreen = screenInfo.screens[i]; + vncScreenPtr pScreenPriv = VNCPTR(pScreen); + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + int sigstate = xf86BlockSIGIO(); + + rfbRootPropertyChange(pScreen); /* Check clipboard */ + + if (pScrn->vtSema) { + rfbCheckFds(pScreen); + httpCheckFds(pScreen); +#ifdef CORBA + corbaCheckFds(); +#endif + } else { + rfbCheckFds(pScreen); + } + + xf86UnblockSIGIO(sigstate); + + pScreen->WakeupHandler = pScreenPriv->WakeupHandler; + (*pScreen->WakeupHandler) (i, blockData, err, pReadmask); + pScreen->WakeupHandler = rfbWakeupHandler; +} + +#ifdef XFree86LOADER +static MODULESETUPPROTO(vncSetup); + +static XF86ModuleVersionInfo vncVersRec = +{ + "vnc", + "xf4vnc Project, see http://xf4vnc.sf.net (based on modular X.org)", + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + 1, 1, 0, + ABI_CLASS_EXTENSION, +#if 0 + ABI_EXTENSION_VERSION, +#else + /* Hack to allow module to work with more servers (vs. 0.3 above) */ + SET_ABI_VERSION(0, 2), +#endif + MOD_CLASS_EXTENSION, + {0,0,0,0} +}; + +XF86ModuleData vncModuleData = { + &vncVersRec, /* vers */ + vncSetup, /* ModuleSetupProc */ + NULL /* ModuleTearDownProc */ +}; + +ModuleInfoRec VNC = { + 1, /* moduleVersion */ + "VNC", /* moduleName */ + NULL, /* module pointer */ + 0, /* refCount */ + VNCAvailableOptions, /* function returning array of OptionsInfoRec */ +}; + +ExtensionModule vncExtensionModule = { + VncExtensionInit, /* initFunc */ + "VNC", /* name */ + NULL, /* disablePtr */ + NULL, /* setupFunc */ + NULL /* initDependencies */ +}; + + +/*ARGSUSED*/ +static pointer +vncSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor) +{ + static Bool Initialised = FALSE; + + if (!Initialised) { + Initialised = TRUE; +#ifndef REMOVE_LOADER_CHECK_MODULE_INFO + if (xf86LoaderCheckSymbol("xf86AddModuleInfo")) +#endif + xf86AddModuleInfo(&VNC, Module); + } + + LoadExtension(&vncExtensionModule, FALSE); + /* add mouse/kbd input drivers */ + vncInitMouse(); + vncInitKeyb(); + xf86Msg(X_INFO, "Ignore errors regarding the loading of the rfbmouse & rfbkeyb drivers\n"); + + return (pointer)TRUE; +} +#endif diff -pNur xorg-server-1.4.orig/hw/xfree86/vnc/vncint.h xorg-server-1.4/hw/xfree86/vnc/vncint.h --- xorg-server-1.4.orig/hw/xfree86/vnc/vncint.h 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/hw/xfree86/vnc/vncint.h 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1,154 @@ +/* + * 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 _VNC_H_ +#define _VNC_H_ + +#include <xorg/xf86Cursor.h> +/*#include <xf86CursorPriv.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; + xf86EnableDisableFBAccessProc *EnableDisableFBAccess; + miPointerSpriteFuncPtr spriteFuncs; + 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 rfbEnableDisableFBAccess (int index, Bool enable); + +#endif /* _VNC_H_ */ + diff -pNur xorg-server-1.4.orig/Makefile.am xorg-server-1.4/Makefile.am --- xorg-server-1.4.orig/Makefile.am 2007-08-23 12:04:52.000000000 -0700 +++ xorg-server-1.4/Makefile.am 2007-09-06 16:09:46.000000000 -0700 @@ -30,6 +30,10 @@ if DBE DBE_DIR=dbe endif +if XCLIPLIST +XCLIPLIST_DIR=xcliplist +endif + SUBDIRS = \ doc \ include \ @@ -54,6 +58,7 @@ SUBDIRS = \ $(XTRAP_DIR) \ $(COMPOSITE_DIR) \ $(GLX_DIR) \ + $(XCLIPLIST_DIR) \ exa \ config \ hw diff -pNur xorg-server-1.4.orig/mi/miinitext.c xorg-server-1.4/mi/miinitext.c --- xorg-server-1.4.orig/mi/miinitext.c 2007-08-23 12:04:54.000000000 -0700 +++ xorg-server-1.4/mi/miinitext.c 2007-09-06 16:09:46.000000000 -0700 @@ -79,6 +79,18 @@ SOFTWARE. #undef XF86VIDMODE #endif +#ifdef VNCSERVER +#undef COMPOSITE +#undef DAMAGE +#undef DBE +#undef RANDR +#undef XF86MISC +#undef XFreeXDGA +#undef XF86DRI +#undef XF86VIDMODE +#undef XFIXES +#endif + #include "misc.h" #include "extension.h" #include "micmap.h" diff -pNur xorg-server-1.4.orig/xcliplist/cliplist.c xorg-server-1.4/xcliplist/cliplist.c --- xorg-server-1.4.orig/xcliplist/cliplist.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/xcliplist/cliplist.c 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1,128 @@ +/* + * Server-side code for the Xcliplist extension + */ + +#if HAVE_DIX_CONFIG_H +#include "dix-config.h" +#endif + +#include <stdio.h> +#include <assert.h> + +#include "dixstruct.h" +#include "extnsionst.h" +#include "windowstr.h" + +#define _XCLIPLIST_SERVER_ +#include <X11/extensions/Xclipliststr.h> + + +static int XClipListErrorBase; +static unsigned char XClipListReqCode = 0; + +static void +XClipListResetProc(ExtensionEntry* extEntry) +{ + (void)extEntry; +} + +static int +ProcXClipListQueryVersion(ClientPtr client) +{ + xXClipListQueryVersionReply rep; + + REQUEST_SIZE_MATCH(xXClipListQueryVersionReq); + rep.type = X_Reply; + rep.length = 0; + rep.sequenceNumber = client->sequence; + rep.majorVersion = XCLIPLIST_MAJOR_VERSION; + rep.minorVersion = XCLIPLIST_MINOR_VERSION; + rep.patchVersion = XCLIPLIST_PATCH_VERSION; + + WriteToClient(client, sizeof(xXClipListQueryVersionReply), (char *)&rep); + return (client->noClientException); +} + +static int +ProcXGetClipList(ClientPtr client) +{ + xXGetClipListReply rep; + WindowPtr pWin; + int i; + BoxPtr pClipRects = NULL; + short xorig, yorig; + REQUEST(xXGetClipListReq); + REQUEST_SIZE_MATCH(xXGetClipListReq); + + rep.type = X_Reply; + rep.length = 0; + rep.sequenceNumber = client->sequence; + + if(!(pWin = (WindowPtr)LOOKUP_DRAWABLE(stuff->windowid, client) )) + { + client->errorValue = stuff->windowid; + return (BadWindow); + } + + rep.num_entries = REGION_NUM_RECTS(&pWin->clipList); + + WriteToClient(client, sizeof(xXGetClipListReply), (char *)&rep); + + pClipRects = REGION_RECTS(&pWin->clipList); + + xorig = pWin->drawable.x; + yorig = pWin->drawable.y; + + for (i = 0; i < rep.num_entries; i++) { + BoxRec box; + /* translate clip rect from screen coords to window coords */ + box.x1 = pClipRects[i].x1 - xorig; + box.y1 = pClipRects[i].y1 - yorig; + box.x2 = pClipRects[i].x2 - xorig; + box.y2 = pClipRects[i].y2 - yorig; + /*memcpy(&box, &pClipRects[i], sizeof(BoxRec));*/ + WriteToClient(client, sizeof(BoxRec), (char *)&box); + } + + return (client->noClientException); +} + +static int +ProcXClipListDispatch (ClientPtr client) +{ + REQUEST(xReq); + + switch (stuff->data) { + case X_XClipListQueryVersion: + return ProcXClipListQueryVersion(client); + case X_XGetClipList: + return ProcXGetClipList(client); + default: + return BadRequest; + } +} + +static int +SProcXClipListDispatch (ClientPtr client) +{ + REQUEST(xReq); + (void)stuff; + return XClipListErrorBase + XClipListClientNotLocal; +} + +void +XClipListExtensionInit(void) +{ + ExtensionEntry* extEntry; + + if ((extEntry = AddExtension(XCLIPLISTNAME, + XClipListNumberEvents, + XClipListNumberErrors, + ProcXClipListDispatch, + SProcXClipListDispatch, + XClipListResetProc, + StandardMinorOpcode))) { + XClipListReqCode = (unsigned char)extEntry->base; + XClipListErrorBase = extEntry->errorBase; + } +} diff -pNur xorg-server-1.4.orig/xcliplist/cliplistmod.c xorg-server-1.4/xcliplist/cliplistmod.c --- xorg-server-1.4.orig/xcliplist/cliplistmod.c 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/xcliplist/cliplistmod.c 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1,46 @@ + +#include "xorg/xf86Module.h" + +extern Bool noTestExtensions; + +static MODULESETUPPROTO(xcliplistSetup); + +extern void XClipListExtensionInit(INITARGS); + +ExtensionModule xcliplistExt = { + XClipListExtensionInit, + "XClipList", + &noTestExtensions, + NULL, + NULL +}; + +static XF86ModuleVersionInfo VersRec = { + "XClipList", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XF86_VERSION_CURRENT, /* XXX fix? */ + 1, 13, 0, + ABI_CLASS_EXTENSION, +#if 0 + ABI_EXTENSION_VERSION, +#else + /* Hack to allow module to work with more servers (vs. 0.3 above) */ + SET_ABI_VERSION(0, 2), +#endif + MOD_CLASS_EXTENSION, + {0,0,0,0} +}; + +XF86ModuleData xcliplistModuleData = { &VersRec, xcliplistSetup, NULL }; + +static pointer +xcliplistSetup(pointer module, pointer opts, int *errmaj, int *errmin) +{ + LoadExtension(&xcliplistExt, FALSE); + + /* Need a non-NULL return value to indicate success */ + return (pointer)1; +} + diff -pNur xorg-server-1.4.orig/xcliplist/Makefile.am xorg-server-1.4/xcliplist/Makefile.am --- xorg-server-1.4.orig/xcliplist/Makefile.am 1969-12-31 16:00:00.000000000 -0800 +++ xorg-server-1.4/xcliplist/Makefile.am 2007-09-06 16:09:46.000000000 -0700 @@ -0,0 +1,18 @@ +#noinst_LTLIBRARIES = libxcliplist.la +libxcliplist_la_LTLIBRARIES = libxcliplist.la + +#AM_CFLAGS = $(DIX_CFLAGS) @SERVER_DEFINES@ @LOADER_DEFINES@ +AM_CFLAGS = $(DIX_CFLAGS) + +libxcliplist_la_LDFLAGS = -module -avoid-version +libxcliplist_ladir = $(moduledir)/extensions + +libxcliplist_la_SOURCES = \ + cliplist.c \ + cliplistmod.c + +## cliplistmod.c + +if XORG +sdk_HEADERS = +endif --- a/hw/dmx/Makefile.am.orig 2008-04-10 20:57:59.000000000 +0200 +++ a/hw/dmx/Makefile.am 2008-06-16 18:29:11.000000000 +0200 @@ -1,6 +1,6 @@ -DIST_SUBDIRS = input config glxProxy examples doc +DIST_SUBDIRS = input vnc config glxProxy examples doc -SUBDIRS = input config examples +SUBDIRS = input vnc config examples bin_PROGRAMS = Xdmx if XINERAMA @@ -85,7 +85,9 @@ @XDMX_LIBS@ \ $(GLX_LIBS) \ input/libdmxinput.a \ + vnc/libdmxvnc.a \ config/libdmxconfig.a \ + -ljpeg -lcrypt \ $(XSERVER_LIBS) Xdmx_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG) --- a/hw/Makefile.am.orig 2008-05-21 23:51:51.000000000 +0200 +++ a/hw/Makefile.am 2008-06-16 18:33:58.000000000 +0200 @@ -34,6 +34,10 @@ XQUARTZ_SUBDIRS = xquartz endif +if VNC +VNC_SUBDIRS = vnc +endif + SUBDIRS = \ $(XORG_SUBDIRS) \ $(XGL_SUBDIRS) \ @@ -41,6 +45,7 @@ $(XVFB_SUBDIRS) \ $(XNEST_SUBDIRS) \ $(DMX_SUBDIRS) \ + $(VNC_SUBDIRS) \ $(KDRIVE_SUBDIRS) \ $(XQUARTZ_SUBDIRS) \ $(XPRINT_SUBDIRS) --- a/hw/xfree86/Makefile.am.orig 2008-05-21 23:51:52.000000000 +0200 +++ a/hw/xfree86/Makefile.am 2008-06-16 18:37:31.000000000 +0200 @@ -8,6 +8,10 @@ DRI2_SUBDIR = dri2 endif +if VNC +VNC_SUBDIR = vnc +endif + if XF86UTILS XF86UTILS_SUBDIR = utils endif @@ -25,12 +29,12 @@ SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support parser rac \ ramdac shadowfb vbe vgahw xaa $(MFB_SUBDIR) $(CFB_SUBDIR) \ xf8_16bpp loader dixmods exa modes \ - $(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR) + $(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR) $(VNC_SUBDIR) DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \ parser rac ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp \ xf8_16bpp xf8_32bpp loader dixmods dri dri2 exa modes \ - utils doc + utils doc vnc bin_PROGRAMS = Xorg
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
