--- /dev/null
+diff -Nru directvnc-0.7.5/src/caps.c directvnc-0.7.5.new/src/caps.c
+--- directvnc-0.7.5/src/caps.c 1970-01-01 01:00:00.000000000 +0100
++++ directvnc-0.7.5.new/src/caps.c 2007-01-15 14:48:51.000000000 +0100
+@@ -0,0 +1,246 @@
++/*
++ * 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.
++ */
++
++/*
++ * caps.c
++ */
++
++#include "caps.h"
++#include "rfbproto.h"
++
++static int CapsIndex(CapsContainer *pcaps, CARD32 code);
++
++/*
++ * The constructor.
++ */
++
++CapsContainer *
++CapsNewContainer(void)
++{
++ CapsContainer *pcaps;
++
++ pcaps = malloc(sizeof(CapsContainer));
++ if (pcaps != NULL) {
++ pcaps->known_count = 0;
++ pcaps->enabled_count = 0;
++ }
++
++ return pcaps;
++}
++
++/*
++ * The destructor.
++ */
++
++void
++CapsDeleteContainer(CapsContainer *pcaps)
++{
++ int i;
++
++ for (i = 0; i < pcaps->known_count; i++) {
++ if (pcaps->descriptions[i] != NULL)
++ free(pcaps->descriptions[i]);
++ }
++
++ free(pcaps);
++}
++
++/*
++ * Add information about a particular capability into the object. There are
++ * two functions to perform this task. These functions overwrite capability
++ * records with the same code.
++ */
++
++void
++CapsAdd(CapsContainer *pcaps,
++ CARD32 code, char *vendor, char *name, char *desc)
++{
++ /* Fill in an rfbCapabilityInfo structure and pass it to CapsAddInfo(). */
++ rfbCapabilityInfo capinfo;
++ capinfo.code = code;
++ memcpy(capinfo.vendorSignature, vendor, sz_rfbCapabilityInfoVendor);
++ memcpy(capinfo.nameSignature, name, sz_rfbCapabilityInfoName);
++ CapsAddInfo(pcaps, &capinfo, desc);
++}
++
++void
++CapsAddInfo(CapsContainer *pcaps,
++ rfbCapabilityInfo *capinfo, char *desc)
++{
++ int i;
++ char *desc_copy;
++
++ i = CapsIndex(pcaps, capinfo->code);
++ if (i == -1) {
++ if (pcaps->known_count >= TIGHTVNC_MAX_CAPS) {
++ return; /* container full */
++ }
++ i = pcaps->known_count++;
++ pcaps->known_list[i] = capinfo->code;
++ pcaps->descriptions[i] = NULL;
++ }
++
++ pcaps->known_info[i] = *capinfo;
++ pcaps->enable_flags[i] = (char)0;
++ if (pcaps->descriptions[i] != NULL) {
++ free(pcaps->descriptions[i]);
++ }
++
++ desc_copy = NULL;
++ if (desc != NULL) {
++ desc_copy = strdup(desc);
++ }
++ pcaps->descriptions[i] = desc_copy;
++}
++
++/*
++ * Check if a capability with the specified code was added earlier.
++ */
++
++static int
++CapsIndex(CapsContainer *pcaps, CARD32 code)
++{
++ int i;
++
++ for (i = 0; i < pcaps->known_count; i++) {
++ if (pcaps->known_list[i] == code)
++ return i;
++ }
++
++ return -1;
++}
++
++int
++CapsIsKnown(CapsContainer *pcaps, CARD32 code)
++{
++ return (CapsIndex(pcaps, code) != -1);
++}
++
++/*
++ * Fill in a rfbCapabilityInfo structure with contents corresponding to the
++ * specified code. Returns True on success, False if the specified code is
++ * not known.
++ */
++
++int
++CapsGetInfo(CapsContainer *pcaps, CARD32 code, rfbCapabilityInfo *capinfo)
++{
++ int i;
++
++ i = CapsIndex(pcaps, code);
++ if (i != -1) {
++ *capinfo = pcaps->known_info[i];
++ return 1;
++ }
++
++ return 0;
++}
++
++/*
++ * Get a description string for the specified capability code. Returns NULL
++ * either if the code is not known, or if there is no description for this
++ * capability.
++ */
++
++char *
++CapsGetDescription(CapsContainer *pcaps, CARD32 code)
++{
++ int i;
++
++ i = CapsIndex(pcaps, code);
++ if (i != -1) {
++ return pcaps->descriptions[i];
++ }
++
++ return NULL;
++}
++
++/*
++ * Mark the specified capability as "enabled". This function checks "vendor"
++ * and "name" signatures in the existing record and in the argument structure
++ * and enables the capability only if both records are the same.
++ */
++
++int
++CapsEnable(CapsContainer *pcaps, rfbCapabilityInfo *capinfo)
++{
++ int i;
++ rfbCapabilityInfo *known;
++
++ i = CapsIndex(pcaps, capinfo->code);
++ if (i == -1)
++ return 0;
++
++ known = &pcaps->known_info[i];
++ if ( memcmp(known->vendorSignature, capinfo->vendorSignature,
++ sz_rfbCapabilityInfoVendor) != 0 ||
++ memcmp(known->nameSignature, capinfo->nameSignature,
++ sz_rfbCapabilityInfoName) != 0 ) {
++ pcaps->enable_flags[i] = (char)0;
++ return 0;
++ }
++
++ /* Cannot happen, but just in case. */
++ if (pcaps->enabled_count >= TIGHTVNC_MAX_CAPS) {
++ pcaps->enable_flags[i] = (char)0;
++ return 0;
++ }
++
++ pcaps->enable_flags[i] = (char)1;
++ pcaps->enabled_list[pcaps->enabled_count++] = capinfo->code;
++ return 1;
++}
++
++/*
++ * Check if the specified capability is known and enabled.
++ */
++
++int
++CapsIsEnabled(CapsContainer *pcaps, CARD32 code)
++{
++ int i;
++
++ i = CapsIndex(pcaps, code);
++ if (i != -1) {
++ return (pcaps->enable_flags[i] != (char)0);
++ }
++
++ return 0;
++}
++
++/*
++ * Return the number of enabled capabilities.
++ */
++
++int CapsNumEnabled(CapsContainer *pcaps)
++{
++ return pcaps->enabled_count;
++}
++
++/*
++ * Return the capability code at the specified index.
++ * If the index is not valid, return 0.
++ */
++
++CARD32
++CapsGetByOrder(CapsContainer *pcaps, int idx)
++{
++ return (idx < pcaps->enabled_count) ? pcaps->enabled_list[idx] : 0;
++}
++
+diff -Nru directvnc-0.7.5/src/caps.h directvnc-0.7.5.new/src/caps.h
+--- directvnc-0.7.5/src/caps.h 1970-01-01 01:00:00.000000000 +0100
++++ directvnc-0.7.5.new/src/caps.h 2007-01-15 14:46:50.000000000 +0100
+@@ -0,0 +1,64 @@
++/*
++ * 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.
++ */
++
++/*
++ * caps.h
++ */
++
++#ifndef _VNC_CAPSCONTAINER
++#define _VNC_CAPSCONTAINER
++
++#include "directvnc.h"
++/* FIXME: Don't limit the number of capabilities. */
++#define TIGHTVNC_MAX_CAPS 64
++
++typedef struct _CapsContainer
++{
++ int known_count;
++ CARD32 known_list[TIGHTVNC_MAX_CAPS];
++ rfbCapabilityInfo known_info[TIGHTVNC_MAX_CAPS];
++ char *descriptions[TIGHTVNC_MAX_CAPS];
++ char enable_flags[TIGHTVNC_MAX_CAPS];
++
++ /* These are redundant, but improve the performance. */
++ int enabled_count;
++ CARD32 enabled_list[TIGHTVNC_MAX_CAPS];
++
++} CapsContainer;
++
++CapsContainer *CapsNewContainer(void);
++void CapsDeleteContainer(CapsContainer *pcaps);
++
++void CapsAdd(CapsContainer *pcaps,
++ CARD32 code, char *vendor, char *name, char *desc);
++void CapsAddInfo(CapsContainer *pcaps,
++ rfbCapabilityInfo *capinfo, char *desc);
++
++int CapsIsKnown(CapsContainer *pcaps, CARD32 code);
++int CapsGetInfo(CapsContainer *pcaps, CARD32 code,
++ rfbCapabilityInfo *capinfo);
++char *CapsGetDescription(CapsContainer *pcaps, CARD32 code);
++
++int CapsEnable(CapsContainer *pcaps, rfbCapabilityInfo *capinfo);
++int CapsIsEnabled(CapsContainer *pcaps, CARD32 code);
++int CapsNumEnabled(CapsContainer *pcaps);
++CARD32 CapsGetByOrder(CapsContainer *pcaps, int idx);
++
++#endif /* _VNC_CAPSCONTAINER */
++
+diff -Nru directvnc-0.7.5/src/cursor.c directvnc-0.7.5.new/src/cursor.c
+--- directvnc-0.7.5/src/cursor.c 2003-01-26 19:47:54.000000000 +0100
++++ directvnc-0.7.5.new/src/cursor.c 2007-01-15 19:59:32.000000000 +0100
+@@ -31,6 +31,15 @@
+ #define True 1
+ #define False 0
+
++#define RGB24_TO_PIXEL(bpp,r,g,b) \
++ ((((CARD##bpp)(r) & 0xFF) * opt.client.redmax + 127) / 255 \
++ << opt.client.redshift | \
++ (((CARD##bpp)(g) & 0xFF) * opt.client.greenmax + 127) / 255 \
++ << opt.client.greenshift | \
++ (((CARD##bpp)(b) & 0xFF) * opt.client.bluemax + 127) / 255 \
++ << opt.client.blueshift)
++
++
+
+ /* Data kept for RichCursor encoding support. */
+ static Bool prevRichCursorSet = False;
+@@ -46,7 +55,6 @@
+ static void SoftCursorDraw(void);
+ static void FreeCursors(Bool setDotCursor);
+
+-
+ /*********************************************************************
+ * HandleRichCursor(). RichCursor shape updates support. This
+ * variation of cursor shape updates cannot be supported directly via
+@@ -54,13 +62,17 @@
+ * buffer (that is why we call it "software cursor").
+ ********************************************************************/
+
+-Bool HandleRichCursor(int xhot, int yhot, int width, int height)
++Bool HandleCursorShape(int xhot, int yhot, int width, int height, CARD32 enc)
+ {
++ int bytesPerPixel;
+ size_t bytesPerRow, bytesMaskData;
++ rfbXCursorColors rgb;
++ CARD32 colors[2];
+ char *buf;
+ CARD8 *ptr;
+ int x, y, b;
+
++ bytesPerPixel = opt.server.bpp / 8;
+ bytesPerRow = (width + 7) / 8;
+ bytesMaskData = bytesPerRow * height;
+
+@@ -75,11 +87,6 @@
+ if (rcSource == NULL)
+ return False;
+
+- if (!read_from_rfb_server(sock, (char *)rcSource,
+- width * height * (opt.client.bpp / 8))) {
+- free(rcSource);
+- return False;
+- }
+
+ /* Read and decode mask data. */
+
+@@ -89,6 +96,64 @@
+ return False;
+ }
+
++ /* Read and decode cursor pixel data, depending on the encoding type. */
++
++ if (enc == rfbEncodingXCursor) {
++
++ /* Read and convert background and foreground colors. */
++ if (!read_from_rfb_server(sock, (char *)&rgb, sz_rfbXCursorColors)) {
++ free(rcSource);
++ free(buf);
++ return False;
++ }
++ colors[0] = RGB24_TO_PIXEL(32, rgb.backRed, rgb.backGreen, rgb.backBlue);
++ colors[1] = RGB24_TO_PIXEL(32, rgb.foreRed, rgb.foreGreen, rgb.foreBlue);
++
++ /* Read 1bpp pixel data into a temporary buffer. */
++ if (!read_from_rfb_server(sock, buf, bytesMaskData)) {
++ free(rcSource);
++ free(buf);
++ return False;
++ }
++
++ /* Convert 1bpp data to byte-wide color indices. */
++ ptr = rcSource;
++ for (y = 0; y < height; y++) {
++ for (x = 0; x < width / 8; x++) {
++ for (b = 7; b >= 0; b--) {
++ *ptr = buf[y * bytesPerRow + x] >> b & 1;
++ ptr += bytesPerPixel;
++ }
++ }
++ for (b = 7; b > 7 - width % 8; b--) {
++ *ptr = buf[y * bytesPerRow + x] >> b & 1;
++ ptr += bytesPerPixel;
++ }
++ }
++
++ /* Convert indices into the actual pixel values. */
++ switch (bytesPerPixel) {
++ case 1:
++ for (x = 0; x < width * height; x++)
++ rcSource[x] = (CARD8)colors[rcSource[x]];
++ break;
++ case 2:
++ for (x = 0; x < width * height; x++)
++ ((CARD16 *)rcSource)[x] = (CARD16)colors[rcSource[x * 2]];
++ break;
++ case 4:
++ for (x = 0; x < width * height; x++)
++ ((CARD32 *)rcSource)[x] = colors[rcSource[x * 4]];
++ break;
++ }
++ } else { /* rfbEncodingRichCursor */
++ if (!read_from_rfb_server(sock, (char *)rcSource,
++ width * height * (opt.client.bpp / 8))) {
++ free(rcSource);
++ return False;
++ }
++ }
++
+ if (!read_from_rfb_server(sock, buf, bytesMaskData)) {
+ free(rcSource);
+ free(buf);
+@@ -201,7 +266,8 @@
+ * SoftCursorUnlock() functions is called.
+ ********************************************************************/
+
+-void SoftCursorMove(int x, int y)
++void
++SoftCursorMove(int x, int y)
+ {
+ if (prevRichCursorSet && !rcCursorHidden) {
+ SoftCursorCopyArea(OPER_RESTORE);
+@@ -303,3 +369,20 @@
+ }
+ }
+
++/*********************************************************************
++ * HandleCursorPos(). Support for the PointerPos pseudo-encoding used
++ * to transmit changes in pointer position from server to clients.
++ * PointerPos encoding is used together with cursor shape updates.
++ ********************************************************************/
++
++int
++HandleCursorPos(int x, int y)
++{
++ if (x >= opt.server.width)
++ x = opt.server.width - 1;
++ if (y >= opt.server.height)
++ y = opt.server.height - 1;
++
++ SoftCursorMove(x, y);
++ return 1;
++}
+diff -Nru directvnc-0.7.5/src/directvnc.h directvnc-0.7.5.new/src/directvnc.h
+--- directvnc-0.7.5/src/directvnc.h 2007-01-15 22:06:18.000000000 +0100
++++ directvnc-0.7.5.new/src/directvnc.h 2007-01-15 20:02:12.000000000 +0100
+@@ -117,6 +117,7 @@
+ {
+ char *servername;
+ int port;
++ char *user;
+ char *password;
+ char *encodings;
+ struct serversettings server;
+@@ -142,6 +143,7 @@
+ int read_from_rfb_server(int sock, char *out, unsigned int n);
+ int write_exact(int sock, char *buf, unsigned int n);
+ int set_non_blocking(int sock);
++int SameMachine(int sock);
+
+ /* dfb.c */
+ void dfb_init(int argc, char *argv[]);
+@@ -157,12 +159,11 @@
+ void dfb_restore_cursor_rect( IDirectFBSurface *surf, int x, int y, int width, int heigth);
+
+ /* cursor.c */
+-int HandleRichCursor(int x, int y, int w, int h);
++int HandleCursorShape(int x, int y, int w, int h, CARD32 enc);
+ void SoftCursorLockArea(int x, int y, int w, int h);
+ void SoftCursorUnlockScreen(void);
+ void SoftCursorMove(int x, int y);
+
+-
+ /* macro for a safe call to DirectFB functions */
+ #define DFBCHECK(x...) \
+ { \
+@@ -174,5 +175,3 @@
+ }
+
+ #endif
+-
+-
+diff -Nru directvnc-0.7.5/src/Makefile.am directvnc-0.7.5.new/src/Makefile.am
+--- directvnc-0.7.5/src/Makefile.am 2003-01-31 10:20:35.000000000 +0100
++++ directvnc-0.7.5.new/src/Makefile.am 2007-01-15 14:07:50.000000000 +0100
+@@ -9,7 +9,7 @@
+ LIBOBJS = @LIBOBJS@
+
+ bin_PROGRAMS = directvnc
+-directvnc_SOURCES = main.c debug.h dfb.c directvnc.h sockets.c args.c\
++directvnc_SOURCES = caps.c caps.h main.c debug.h dfb.c directvnc.h sockets.c args.c\
+ rfb.c getopt.c getopt1.c getopt.h\
+ d3des.c d3des.h vncauth.c vncauth.h jpeg.c jpeg.h\
+ tight.c tight.h rfbproto.h keysym.h keysymdef.h \
+diff -Nru directvnc-0.7.5/src/rfb.c directvnc-0.7.5.new/src/rfb.c
+--- directvnc-0.7.5/src/rfb.c 2003-01-31 09:41:03.000000000 +0100
++++ directvnc-0.7.5.new/src/rfb.c 2007-01-15 21:49:58.000000000 +0100
+@@ -17,7 +17,8 @@
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+-
++#include <pwd.h>
++#include <sys/types.h>
+ #include <unistd.h>
+ #include <sys/socket.h>
+ #include <errno.h>
+@@ -28,15 +29,25 @@
+ #include <math.h>
+ #include <zlib.h>
+
++#include "caps.h"
+ #include "directvnc.h"
+ #include "tight.h"
+
++static void InitCapabilities(void);
++static int SetupTunneling(void);
++static int ReadSecurityType(void);
++static int SelectSecurityType(void);
++static int PerformAuthenticationTight(void);
++static int AuthenticateVNC(void);
++static int AuthenticateUnixLogin(void);
++static int ReadInteractionCaps(void);
++static int ReadCapabilityList(CapsContainer *caps, int count);
++
+ int _rfb_negotiate_protocol ();
+ int _rfb_authenticate ();
+ int _rfb_initialise_client ();
+ int _rfb_initialise_server ();
+
+-
+ static int _handle_raw_encoded_message(rfbFramebufferUpdateRectHeader rectheader);
+ static int _handle_copyrect_encoded_message(rfbFramebufferUpdateRectHeader rectheader);
+ static int _handle_rre_encoded_message(rfbFramebufferUpdateRectHeader rectheader);
+@@ -44,6 +55,63 @@
+ static int _handle_hextile_encoded_message(rfbFramebufferUpdateRectHeader rectheader);
+ static int _handle_richcursor_message(rfbFramebufferUpdateRectHeader rectheader);
+
++static int tightVncProtocol = 0;
++static CapsContainer *tunnelCaps; /* known tunneling/encryption methods */
++static CapsContainer *authCaps; /* known authentication schemes */
++static CapsContainer *serverMsgCaps; /* known non-standard server messages */
++static CapsContainer *clientMsgCaps; /* known non-standard client messages */
++static CapsContainer *encodingCaps; /* known encodings besides Raw */
++static int tunnelSpecified = 0;
++
++/*
++ * InitCapabilities.
++ */
++
++static void
++InitCapabilities(void)
++{
++ tunnelCaps = CapsNewContainer();
++ authCaps = CapsNewContainer();
++ serverMsgCaps = CapsNewContainer();
++ clientMsgCaps = CapsNewContainer();
++ encodingCaps = CapsNewContainer();
++
++ /* Supported authentication methods */
++ CapsAdd(authCaps, rfbAuthVNC, rfbStandardVendor, sig_rfbAuthVNC,
++ "Standard VNC password authentication");
++ CapsAdd(authCaps, rfbAuthUnixLogin, rfbTightVncVendor, sig_rfbAuthUnixLogin,
++ "Login-style Unix authentication");
++
++ /* Supported encoding types */
++ CapsAdd(encodingCaps, rfbEncodingCopyRect, rfbStandardVendor,
++ sig_rfbEncodingCopyRect, "Standard CopyRect encoding");
++ CapsAdd(encodingCaps, rfbEncodingRRE, rfbStandardVendor,
++ sig_rfbEncodingRRE, "Standard RRE encoding");
++ CapsAdd(encodingCaps, rfbEncodingCoRRE, rfbStandardVendor,
++ sig_rfbEncodingCoRRE, "Standard CoRRE encoding");
++ CapsAdd(encodingCaps, rfbEncodingHextile, rfbStandardVendor,
++ sig_rfbEncodingHextile, "Standard Hextile encoding");
++ CapsAdd(encodingCaps, rfbEncodingZlib, rfbTridiaVncVendor,
++ sig_rfbEncodingZlib, "Zlib encoding from TridiaVNC");
++ CapsAdd(encodingCaps, rfbEncodingTight, rfbTightVncVendor,
++ sig_rfbEncodingTight, "Tight encoding by Constantin Kaplinsky");
++
++ /* Supported "fake" encoding types */
++ CapsAdd(encodingCaps, rfbEncodingCompressLevel0, rfbTightVncVendor,
++ sig_rfbEncodingCompressLevel0, "Compression level");
++ CapsAdd(encodingCaps, rfbEncodingQualityLevel0, rfbTightVncVendor,
++ sig_rfbEncodingQualityLevel0, "JPEG quality level");
++ CapsAdd(encodingCaps, rfbEncodingXCursor, rfbTightVncVendor,
++ sig_rfbEncodingXCursor, "X-style cursor shape update");
++ CapsAdd(encodingCaps, rfbEncodingRichCursor, rfbTightVncVendor,
++ sig_rfbEncodingRichCursor, "Rich-color cursor shape update");
++ CapsAdd(encodingCaps, rfbEncodingPointerPos, rfbTightVncVendor,
++ sig_rfbEncodingPointerPos, "Pointer position update");
++ CapsAdd(encodingCaps, rfbEncodingLastRect, rfbTightVncVendor,
++ sig_rfbEncodingLastRect, "LastRect protocol extension");
++}
++
++
+ /*
+ * ConnectToRFBServer.
+ */
+@@ -100,89 +168,393 @@
+ int
+ rfb_initialise_connection ()
+ {
+- if (!_rfb_negotiate_protocol()) return 0;
+- if (!_rfb_authenticate()) return 0;
+- if (!_rfb_initialise_client()) return 0;
+- if (!_rfb_initialise_server()) return 0;
+-
+- return(1);
++ if (!_rfb_negotiate_protocol()) return 0;
++ if (!_rfb_initialise_client()) return 0;
++ if (!_rfb_initialise_server()) return 0;
++ return 1;
+ }
+
+ int
+ _rfb_negotiate_protocol()
+ {
+ rfbProtocolVersionMsg msg;
++ int server_major, server_minor;
++ int viewer_major, viewer_minor;
++ int secType;
+
+ /* read the protocol version the server uses */
+ if (!read_from_rfb_server(sock, (char*)&msg, sz_rfbProtocolVersionMsg))
+ return 0;
+- /* FIXME actually do something with that information ;) */
+
++ msg[sz_rfbProtocolVersionMsg] = 0;
++
++ if (sscanf(msg, rfbProtocolVersionFormat, &server_major, &server_minor) != 2) {
++ return 0;
++ }
++ viewer_major = rfbProtocolMajorVersion;
++ if (server_major == 3 && server_minor >= rfbProtocolMinorVersion) {
++ /* the server supports at least the standard protocol 3.7 */
++ viewer_minor = rfbProtocolMinorVersion;
++ } else {
++ /* any other server version, request the standard 3.3 */
++ viewer_minor = rfbProtocolFallbackMinorVersion;
++ }
+ /* send the protocol version we want to use */
+- sprintf(msg, rfbProtocolVersionFormat,
+- rfbProtocolMajorVersion,
+- rfbProtocolMinorVersion);
++ sprintf(msg, rfbProtocolVersionFormat,
++ viewer_major,
++ viewer_minor);
+ if (!write_exact (sock, msg, sz_rfbProtocolVersionMsg))
+ return 0;
+
+- return 1;
++ /* Read or select the security type. */
++ if (viewer_minor == rfbProtocolMinorVersion) {
++ secType = SelectSecurityType();
++ } else {
++ secType = ReadSecurityType();
++ }
++ if (secType == rfbConnFailed)
++ return 0;
++
++ return _rfb_authenticate(secType);
+ }
+
++static int
++ReadSecurityType(void)
++{
++ CARD32 secType;
++ if (!read_from_rfb_server(sock, (char *)&secType, sizeof(secType))) {
++ return rfbConnFailed;
++ }
++ return Swap32IfLE(secType);
++}
+
+-int
+-_rfb_authenticate()
++static int
++SelectSecurityType(void)
+ {
+- CARD32 authscheme;
+-
+- read_from_rfb_server(sock, (char *)&authscheme, 4);
+- authscheme = Swap32IfLE(authscheme);
+- switch (authscheme)
+- {
+- CARD32 reason_length;
+- CARD8 *reason_string;
+- CARD8 challenge_and_response[CHALLENGESIZE];
+- CARD32 auth_result;
+-
+- case rfbConnFailed:
+- fprintf(stderr, "DIRECTVNC: Connection to VNC server failed\n");
+- read_from_rfb_server(sock, (char *)&reason_length, 4);
+- reason_length = Swap32IfLE(reason_length);
+- reason_string = malloc(sizeof(CARD8) * reason_length);
+- read_from_rfb_server(sock, (char *)reason_string, reason_length);
+- fprintf(stderr, "Errormessage: %s\n", reason_string);
+- return (0);
+- case rfbVncAuth:
++ CARD8 nSecTypes;
++ char *secTypeNames[] = {"None", "VncAuth"};
++ CARD8 knownSecTypes[] = {rfbNoAuth, rfbVncAuth};
++ int nKnownSecTypes = sizeof(knownSecTypes);
++ CARD8 *secTypes;
++ CARD8 secType = rfbConnFailed;
++ int i, j;
++
++ /* Read the list of security types. */
++ if (!read_from_rfb_server(sock, (char *)&nSecTypes, sizeof(nSecTypes)))
++ return rfbConnFailed;
++ if (nSecTypes == 0) {
++ return rfbConnFailed;
++ }
++
++ secTypes = malloc(nSecTypes);
++ if (!read_from_rfb_server(sock, (char *)secTypes, nSecTypes))
++ return rfbConnFailed;
++
++ /* Find out if the server supports TightVNC protocol extensions */
++ for (j = 0; j < (int)nSecTypes; j++) {
++ if (secTypes[j] == rfbSecTypeTight) {
++ free(secTypes);
++ secType = rfbSecTypeTight;
++ if (!write_exact(sock, (char *)&secType, sizeof(secType)))
++ return rfbConnFailed;
++ fprintf(stderr, "Enabling TightVNC protocol extensions\n");
++ return rfbSecTypeTight;
++ }
++ }
++ /* Find first supported security type */
++ for (j = 0; j < (int)nSecTypes; j++) {
++ for (i = 0; i < nKnownSecTypes; i++) {
++ if (secTypes[j] == knownSecTypes[i]) {
++ secType = secTypes[j];
++ if (!write_exact(sock, (char *)&secType, sizeof(secType))) {
++ free(secTypes);
++ return rfbConnFailed;
++ }
++ break;
++ }
++ }
++ if (secType != rfbConnFailed) break;
++ }
++ free(secTypes);
++ if (secType == rfbConnFailed)
++ fprintf(stderr, "Server did not offer supported security type\n");
++ return (int)secType;
+
+- /* we didnt get a password on the command line, so go get one */
+- if (!opt.password) opt.password = getpass("Password: ");
++}
+
+- if (!read_from_rfb_server(sock, challenge_and_response, CHALLENGESIZE))
+- return 0;
+- vncEncryptBytes(challenge_and_response, opt.password);
+- if (!write_exact(sock, challenge_and_response, CHALLENGESIZE))
+- return 0;
+- if (!read_from_rfb_server(sock, (char*)&auth_result, 4))
++/*
++ * Standard VNC authentication.
++ */
++
++static int
++AuthenticateVNC(void)
++{
++ CARD32 authScheme, auth_result;
++ CARD8 challenge[CHALLENGESIZE];
++ char *passwd;
++ char buffer[64];
++ char* cstatus;
++ int len;
++
++ fprintf(stderr, "Performing standard VNC authentication\n");
++
++ if (!read_from_rfb_server(sock, (char *)challenge, CHALLENGESIZE))
++ return 0;
++
++
++ /* we get a password on the command line, so go get one */
++ if (!opt.password) opt.password = getpass("Password: ");
++ if (strlen(opt.password) > 8) {
++ opt.password[8] = '\0';
++ }
++
++ vncEncryptBytes(challenge, opt.password);
++ /* Lose the password from memory */
++ memset(opt.password, '\0', strlen(opt.password));
++
++ if (!write_exact(sock, challenge, CHALLENGESIZE))
++ return 0;
++ if (!read_from_rfb_server(sock, (char*)&auth_result, 4))
+ return 0;
+- auth_result = Swap32IfLE(auth_result);
+- switch (auth_result)
+- {
+- case rfbVncAuthFailed:
+- fprintf(stderr, "Authentication Failed\n");
+- return (0);
+- case rfbVncAuthTooMany:
+- fprintf(stderr, "Too many connections\n");
+- return (0);
+- case rfbVncAuthOK:
+- fprintf(stderr, "Authentication OK\n");
+- break;
+- }
+- break;
+- case rfbNoAuth:
+- break;
++ auth_result = Swap32IfLE(auth_result);
++ switch (auth_result) {
++ case rfbVncAuthFailed:
++ fprintf(stderr, "Authentication Failed\n");
++ return 0;
++ case rfbVncAuthTooMany:
++ fprintf(stderr, "Too many connections\n");
++ return 0;
++ case rfbVncAuthOK:
++ fprintf(stderr, "Authentication OK\n");
++ break;
++ }
++ return 1;
++}
++
++
++/*
++ * Read the list of rfbCapabilityInfo structures and enable corresponding
++ * capabilities in the specified container. The count argument specifies how
++ * many records to read from the socket.
++ */
++
++static int
++ReadCapabilityList(CapsContainer *caps, int count)
++{
++ rfbCapabilityInfo msginfo;
++ int i;
++
++ for (i = 0; i < count; i++) {
++ if (!read_from_rfb_server(sock, (char *)&msginfo, sz_rfbCapabilityInfo))
++ return 0;
++ msginfo.code = Swap32IfLE(msginfo.code);
++ CapsEnable(caps, &msginfo);
++ }
++
++ return 1;
++}
++
++/*
++ * Unix login-style authentication.
++ */
++
++static int
++AuthenticateUnixLogin(void)
++{
++ CARD32 loginLen, passwdLen, authResult;
++ char *login;
++ char *passwd;
++ struct passwd *ps;
++
++ fprintf(stderr, "Performing Unix login-style authentication\n");
++
++ if (opt.user) {
++ login = opt.user;
++ } else {
++ ps = getpwuid(getuid());
++ login = ps->pw_name;
++ }
++
++ fprintf(stderr, "Using user name \"%s\"\n", login);
++
++ passwd = getpass("Password: ");
++
++ if (!passwd || strlen(passwd) == 0) {
++ fprintf(stderr, "Reading password failed\n");
++ return 0;
++ }
++
++ loginLen = Swap32IfLE((CARD32)strlen(login));
++ passwdLen = Swap32IfLE((CARD32)strlen(passwd));
++
++ if (!write_exact(sock, (char *)&loginLen, sizeof(loginLen)) ||
++ !write_exact(sock, (char *)&passwdLen, sizeof(passwdLen)))
++ return 0;
++
++ if (!write_exact(sock, login, strlen(login)) ||
++ !write_exact(sock, passwd, strlen(passwd)))
++ return 0;
++
++ /* Lose the password from memory */
++ memset(passwd, '\0', strlen(passwd));
++
++ if (!read_from_rfb_server(sock, (char *)&authResult, sizeof(authResult)))
++ return 0;
++
++ authResult = Swap32IfLE(authResult);
++
++ switch (authResult) {
++ case rfbVncAuthOK:
++ fprintf(stderr, "Authentication succeeded\n");
++ break;
++ case rfbVncAuthFailed:
++ fprintf(stderr, "Authentication failed\n");
++ return 0;
++ case rfbVncAuthTooMany:
++ fprintf(stderr, "Authentication failed - too many tries\n");
++ return 0;
++ default:
++ fprintf(stderr, "Unknown authentication result: %d\n",
++ (int)authResult);
++ return 0;
++ }
++
++ return 1;
++}
++
++
++int
++_rfb_authenticate(CARD32 authscheme)
++{
++ switch (authscheme) {
++ CARD32 reason_length;
++ CARD8 *reason_string;
++ CARD8 challenge_and_response[CHALLENGESIZE];
++ CARD32 auth_result;
++
++ case rfbConnFailed:
++ fprintf(stderr, "DIRECTVNC: Connection to VNC server failed\n");
++ read_from_rfb_server(sock, (char *)&reason_length, 4);
++ reason_length = Swap32IfLE(reason_length);
++ reason_string = malloc(sizeof(CARD8) * reason_length);
++ read_from_rfb_server(sock, (char *)reason_string, reason_length);
++ fprintf(stderr, "Errormessage: %s\n", reason_string);
++ return 0;
++ case rfbVncAuth:
++ return AuthenticateVNC();
++ case rfbNoAuth:
++ break;
++ case rfbSecTypeTight:
++ tightVncProtocol = 1;
++ InitCapabilities();
++ if (!SetupTunneling()) return 0;
++ if (!PerformAuthenticationTight()) return 0;
++ break;
++ default:
++ fprintf(stderr, "Internal error: Invalid security type\n");
++ return 0;
+ }
+ return 1;
+ }
+
++static int
++SetupTunneling(void)
++{
++ rfbTunnelingCapsMsg caps;
++ CARD32 tunnelType;
++
++ /* In the protocol version 3.7t, the server informs us about
++ supported tunneling methods. Here we read this information. */
++
++ if (!read_from_rfb_server(sock, (char *)&caps, sz_rfbTunnelingCapsMsg)) return 0;
++ caps.nTunnelTypes = Swap32IfLE(caps.nTunnelTypes);
++
++ if (caps.nTunnelTypes) {
++ if (!ReadCapabilityList(tunnelCaps, caps.nTunnelTypes)) return 0;
++
++ /* We cannot do tunneling anyway yet. */
++ tunnelType = Swap32IfLE(rfbNoTunneling);
++ if (!write_exact(sock, (char *)&tunnelType, sizeof(tunnelType))) return 0;
++ }
++ return 1;
++}
++
++/* Negotiate authentication scheme (protocol version 3.7t) */
++static int
++PerformAuthenticationTight(void)
++{
++ rfbAuthenticationCapsMsg caps;
++ CARD32 authScheme;
++ int i;
++
++ /* In the protocol version 3.7t, the server informs us about supported
++ authentication schemes. Here we read this infomation. */
++
++ if (!read_from_rfb_server(sock, (char *)&caps, sz_rfbAuthenticationCapsMsg)) return 0;
++
++ caps.nAuthTypes = Swap32IfLE(caps.nAuthTypes);
++
++ if (!caps.nAuthTypes) {
++ fprintf(stderr, "No authentication needed\n");
++ return 1;
++ }
++
++ if (!ReadCapabilityList(authCaps, caps.nAuthTypes)) return 0;
++
++ /* Prefer Unix login authentication if a user name was given. */
++ if (opt.user && CapsIsEnabled(authCaps, rfbAuthUnixLogin)) {
++ authScheme = Swap32IfLE(rfbAuthUnixLogin);
++ if (!write_exact(sock, (char *)&authScheme, sizeof(authScheme))) return 0;
++ return AuthenticateUnixLogin();
++ }
++
++ /* Otherwise, try server's preferred authentication scheme. */
++ for (i = 0; i < CapsNumEnabled(authCaps); i++) {
++ authScheme = CapsGetByOrder(authCaps, i);
++ if (authScheme != rfbAuthUnixLogin && authScheme != rfbAuthVNC) continue; /* unknown scheme - cannot use it */
++ authScheme = Swap32IfLE(authScheme);
++ if (!write_exact(sock, (char *)&authScheme, sizeof(authScheme))) return 0;
++ authScheme = Swap32IfLE(authScheme); /* convert it back */
++
++ if (authScheme == rfbAuthUnixLogin) {
++ return AuthenticateUnixLogin();
++ } else if (authScheme == rfbAuthVNC) {
++ return AuthenticateVNC();
++ } else {
++ fprintf(stderr, "Should never happen\n");
++ /* Should never happen. */
++ return 0;
++ }
++ }
++
++ fprintf(stderr, "No suitable authentication schemes offered by server\n");
++ return 0;
++}
++
++/*
++ * In the protocol version 3.7t, the server informs us about supported
++ * protocol messages and encodings. Here we read this information.
++ */
++
++static int
++ReadInteractionCaps(void)
++{
++ rfbInteractionCapsMsg intr_caps;
++
++ /* Read the counts of list items following */
++ if (!read_from_rfb_server(sock, (char *)&intr_caps, sz_rfbInteractionCapsMsg))
++ return 0;
++ intr_caps.nServerMessageTypes = Swap16IfLE(intr_caps.nServerMessageTypes);
++ intr_caps.nClientMessageTypes = Swap16IfLE(intr_caps.nClientMessageTypes);
++ intr_caps.nEncodingTypes = Swap16IfLE(intr_caps.nEncodingTypes);
++
++ /* Read the lists of server- and client-initiated messages */
++ return (ReadCapabilityList(serverMsgCaps, intr_caps.nServerMessageTypes) &&
++ ReadCapabilityList(clientMsgCaps, intr_caps.nClientMessageTypes) &&
++ ReadCapabilityList(encodingCaps, intr_caps.nEncodingTypes));
++}
++
++
+ int
+ _rfb_initialise_client()
+ {
+@@ -220,10 +592,166 @@
+
+ if (!read_from_rfb_server(sock, opt.server.name, len))
+ return 0;
+-
++ if (tightVncProtocol) {
++ /* Read interaction capabilities (protocol 3.7t) */
++ if (!ReadInteractionCaps())
++ return 0;
++ }
+ return 1;
+ }
+
++/*
++ * SetFormatAndEncodings.
++ */
++
++int
++rfb_set_format_and_encodings()
++{
++ rfbSetPixelFormatMsg spf;
++ char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4];
++ rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf;
++ CARD32 *encs = (CARD32 *)(&buf[sz_rfbSetEncodingsMsg]);
++ int len = 0;
++ int requestCompressLevel = 0;
++ int requestQualityLevel = 0;
++ int requestLastRectEncoding = 0;
++
++ spf.type = 0;
++ spf.format.bitsPerPixel = opt.client.bpp;
++ spf.format.depth = opt.client.depth;
++ spf.format.bigEndian = opt.client.bigendian;
++ spf.format.trueColour = opt.client.truecolour;
++ spf.format.redMax = Swap16IfLE(opt.client.redmax);
++ spf.format.greenMax = Swap16IfLE(opt.client.greenmax);
++ spf.format.blueMax = Swap16IfLE(opt.client.bluemax);
++ spf.format.redShift =opt.client.redshift;
++ spf.format.greenShift = opt.client.greenshift;
++ spf.format.blueShift = opt.client.blueshift;
++
++ if (!write_exact(sock, (char *)&spf, sz_rfbSetPixelFormatMsg))
++ return 0;
++
++ se->type = rfbSetEncodings;
++ se->nEncodings = 0;
++
++ if (opt.encodings) {
++ char *encStr = opt.encodings;
++ int encStrLen;
++ do {
++ char *nextEncStr = strchr(encStr, ' ');
++ if (nextEncStr) {
++ encStrLen = nextEncStr - encStr;
++ nextEncStr++;
++ } else {
++ encStrLen = strlen(encStr);
++ }
++
++ if (strncasecmp(encStr,"raw",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw);
++ } else if (strncasecmp(encStr,"copyrect",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect);
++ } else if (strncasecmp(encStr,"tight",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight);
++ requestLastRectEncoding = 1;
++ if (opt.client.compresslevel >= 0 && opt.client.compresslevel <= 9)
++ requestCompressLevel = 1;
++ requestQualityLevel = 1;
++ } else if (strncasecmp(encStr,"hextile",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile);
++ } else if (strncasecmp(encStr,"zlib",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib);
++ if (opt.client.compresslevel >= 0 && opt.client.compresslevel <= 9)
++ requestCompressLevel = 1;
++ } else if (strncasecmp(encStr,"corre",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCoRRE);
++ } else if (strncasecmp(encStr,"rre",encStrLen) == 0) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRRE);
++ } else {
++ fprintf(stderr,"Unknown encoding '%.*s'\n",encStrLen,encStr);
++ }
++
++ encStr = nextEncStr;
++ } while (encStr && se->nEncodings < MAX_ENCODINGS);
++
++ if (se->nEncodings < MAX_ENCODINGS && requestCompressLevel) {
++ encs[se->nEncodings++] = Swap32IfLE(opt.client.compresslevel +
++ rfbEncodingCompressLevel0);
++ }
++
++ if (se->nEncodings < MAX_ENCODINGS && requestQualityLevel) {
++ if (opt.client.quality < 0 || opt.client.quality > 9)
++ opt.client.quality = 5;
++ encs[se->nEncodings++] = Swap32IfLE(opt.client.quality +
++ rfbEncodingQualityLevel0);
++ }
++
++ if (opt.localcursor) {
++ if (se->nEncodings < MAX_ENCODINGS)
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingXCursor);
++ if (se->nEncodings < MAX_ENCODINGS)
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRichCursor);
++ if (se->nEncodings < MAX_ENCODINGS)
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingPointerPos);
++ }
++
++ if (se->nEncodings < MAX_ENCODINGS && requestLastRectEncoding) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect);
++ }
++ } else {
++ if (SameMachine(sock)) {
++ if (!tunnelSpecified) {
++ fprintf(stderr,"Same machine: preferring raw encoding\n");
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw);
++ } else {
++ fprintf(stderr,"Tunneling active: preferring tight encoding\n");
++ }
++ }
++
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCoRRE);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRRE);
++
++ if (opt.client.compresslevel >= 0 && opt.client.compresslevel <= 9) {
++ encs[se->nEncodings++] = Swap32IfLE(opt.client.compresslevel +
++ rfbEncodingCompressLevel0);
++ } else if (!tunnelSpecified) {
++ /* If -tunnel option was provided, we assume that server machine is
++ not in the local network so we use default compression level for
++ tight encoding instead of fast compression. Thus we are
++ requesting level 1 compression only if tunneling is not used. */
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCompressLevel1);
++ }
++#if 0
++ if (appData.enableJPEG) {
++ if (appData.qualityLevel < 0 || appData.qualityLevel > 9)
++ appData.qualityLevel = 5;
++ encs[se->nEncodings++] = Swap32IfLE(appData.qualityLevel +
++ rfbEncodingQualityLevel0);
++ }
++#endif
++
++ if (opt.localcursor) {
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingXCursor);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRichCursor);
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingPointerPos);
++ }
++
++ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect);
++ }
++
++ len = sz_rfbSetEncodingsMsg + se->nEncodings * 4;
++
++ se->nEncodings = Swap16IfLE(se->nEncodings);
++
++ if (!write_exact(sock, buf, len)) return 0;
++
++ return 1;
++}
++
++#if 0
+ int
+ rfb_set_format_and_encodings()
+ {
+@@ -312,7 +840,7 @@
+
+ return(1);
+ }
+-
++#endif
+
+ int
+ rfb_send_update_request(int incremental)
+@@ -347,84 +875,93 @@
+ rfbFramebufferUpdateRectHeader rectheader;
+
+ if (!read_from_rfb_server(sock, (char*)&msg, 1)) return 0;
+- switch (msg.type)
+- {
+- int i;
+- case rfbFramebufferUpdate:
+- read_from_rfb_server(sock, ((char*)&msg.fu)+1, sz_rfbFramebufferUpdateMsg-1);
+- msg.fu.nRects = Swap16IfLE(msg.fu.nRects);
+- for (i=0;i< msg.fu.nRects;i++)
+- {
+- read_from_rfb_server(sock, (char*)&rectheader,
+- sz_rfbFramebufferUpdateRectHeader);
+- rectheader.r.x = Swap16IfLE(rectheader.r.x);
+- rectheader.r.y = Swap16IfLE(rectheader.r.y);
+- rectheader.r.w = Swap16IfLE(rectheader.r.w);
+- rectheader.r.h = Swap16IfLE(rectheader.r.h);
+- rectheader.encoding = Swap32IfLE(rectheader.encoding);
+- SoftCursorLockArea(rectheader.r.x, rectheader.r.y, rectheader.r.w, rectheader.r.h);
+- switch (rectheader.encoding)
+- {
+- case rfbEncodingRaw:
+- _handle_raw_encoded_message(rectheader);
+- break;
+- case rfbEncodingCopyRect:
+- _handle_copyrect_encoded_message(rectheader);
+- break;
+- case rfbEncodingRRE:
+- _handle_rre_encoded_message(rectheader);
+- break;
+- case rfbEncodingCoRRE:
+- _handle_corre_encoded_message(rectheader);
+- break;
+- case rfbEncodingHextile:
+- _handle_hextile_encoded_message(rectheader);
+- break;
+- case rfbEncodingTight:
+- _handle_tight_encoded_message(rectheader);
+- break;
+- case rfbEncodingZlib:
+- _handle_zlib_encoded_message(rectheader);
+- break;
+- case rfbEncodingRichCursor:
+- _handle_richcursor_message(rectheader);
+- break;
++ switch (msg.type) {
++ int i;
++ case rfbFramebufferUpdate:
++ read_from_rfb_server(sock, ((char*)&msg.fu)+1, sz_rfbFramebufferUpdateMsg-1);
++ msg.fu.nRects = Swap16IfLE(msg.fu.nRects);
++
++ for (i=0;i< msg.fu.nRects;i++) {
++ read_from_rfb_server(sock, (char*)&rectheader, sz_rfbFramebufferUpdateRectHeader);
++ rectheader.r.x = Swap16IfLE(rectheader.r.x);
++ rectheader.r.y = Swap16IfLE(rectheader.r.y);
++ rectheader.r.w = Swap16IfLE(rectheader.r.w);
++ rectheader.r.h = Swap16IfLE(rectheader.r.h);
++ rectheader.encoding = Swap32IfLE(rectheader.encoding);
++ if (rectheader.encoding == rfbEncodingLastRect) break;
++
++ if (rectheader.encoding == rfbEncodingPointerPos) {
++ if (!HandleCursorPos(rectheader.r.x, rectheader.r.y)) {
++ return 0;
++ }
++ continue;
++ }
++ SoftCursorLockArea(rectheader.r.x, rectheader.r.y, rectheader.r.w, rectheader.r.h);
++
++ switch (rectheader.encoding) {
++ case rfbEncodingRaw:
++ _handle_raw_encoded_message(rectheader);
++ break;
++ case rfbEncodingCopyRect:
++ _handle_copyrect_encoded_message(rectheader);
++ break;
++ case rfbEncodingRRE:
++ _handle_rre_encoded_message(rectheader);
++ break;
++ case rfbEncodingCoRRE:
++ _handle_corre_encoded_message(rectheader);
++ break;
++ case rfbEncodingHextile:
++ _handle_hextile_encoded_message(rectheader);
++ break;
++ case rfbEncodingTight:
++ _handle_tight_encoded_message(rectheader);
++ break;
++ case rfbEncodingZlib:
++ _handle_zlib_encoded_message(rectheader);
++ break;
++ case rfbEncodingRichCursor:
++ case rfbEncodingXCursor:
++ _handle_richcursor_message(rectheader);
++ break;
++#if 0
+ case rfbEncodingLastRect:
+- printf("LAST\n");
++ fprintf(stderr, "LAST\n");
+ break;
+-
+- default:
+- printf("Unknown encoding\n");
+- return 0;
+- break;
+- }
+- /* Now we may discard "soft cursor locks". */
+- SoftCursorUnlockScreen();
++#endif
++ default:
++ fprintf(stderr, "Unknown encoding: %x\n", rectheader.encoding);
++ return 0;
++ break;
++ }
++ /* Now we may discard "soft cursor locks". */
++ SoftCursorUnlockScreen();
++ }
++ if (!rfb_send_update_request(1)) return 0;
+
+- }
+- break;
+- case rfbSetColourMapEntries:
+- fprintf(stderr, "SetColourMapEntries\n");
+- read_from_rfb_server(sock, ((char*)&msg.scme)+1, sz_rfbSetColourMapEntriesMsg-1);
+- break;
+- case rfbBell:
+- fprintf(stderr, "Bell message. Unimplemented.\n");
+- break;
+- case rfbServerCutText:
+- fprintf(stderr, "ServerCutText. Unimplemented.\n");
+- read_from_rfb_server(sock, ((char*)&msg.sct)+1,
+- sz_rfbServerCutTextMsg-1);
+- size = Swap32IfLE(msg.sct.length);
+- buf = malloc(sizeof(char) * size);
+- read_from_rfb_server(sock, buf, size);
+- buf[size]=0;
+- printf("%s\n", buf);
+- free(buf);
+- break;
+- default:
+- printf("Unknown server message. Type: %i\n", msg.type);
+- return 0;
+- break;
++ break;
++
++ case rfbSetColourMapEntries:
++ fprintf(stderr, "SetColourMapEntries\n");
++ read_from_rfb_server(sock, ((char*)&msg.scme)+1, sz_rfbSetColourMapEntriesMsg-1);
++ break;
++ case rfbBell:
++ fprintf(stderr, "Bell message. Unimplemented.\n");
++ break;
++ case rfbServerCutText:
++ fprintf(stderr, "ServerCutText. Unimplemented.\n");
++ read_from_rfb_server(sock, ((char*)&msg.sct)+1, sz_rfbServerCutTextMsg-1);
++ size = Swap32IfLE(msg.sct.length);
++ buf = malloc(sizeof(char) * size);
++ read_from_rfb_server(sock, buf, size);
++ buf[size]=0;
++ printf("%s\n", buf);
++ free(buf);
++ break;
++ default:
++ printf("Unknown server message. Type: %i\n", msg.type);
++ return 0;
++ break;
+ }
+ return(1);
+ }
+@@ -688,7 +1225,7 @@
+ static int
+ _handle_richcursor_message(rfbFramebufferUpdateRectHeader rectheader)
+ {
+- return HandleRichCursor(rectheader.r.x, rectheader.r.y, rectheader.r.w, rectheader.r.h);
++ return HandleCursorShape(rectheader.r.x, rectheader.r.y, rectheader.r.w, rectheader.r.h, rectheader.encoding);
+ }
+
+ void
+diff -Nru directvnc-0.7.5/src/rfbproto.h directvnc-0.7.5.new/src/rfbproto.h
+--- directvnc-0.7.5/src/rfbproto.h 2002-07-07 18:50:02.000000000 +0200
++++ directvnc-0.7.5.new/src/rfbproto.h 2007-01-15 16:42:12.000000000 +0100
+@@ -1,3 +1,5 @@
++#ifndef VNC_RFBPROTO_H
++#define VNC_RFBPROTO_H
+ /*
+ * Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved.
+ * Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
+@@ -20,7 +22,7 @@
+ */
+
+ /*
+- * rfbproto.h - header file for the RFB protocol version 3.3
++ * rfbproto.h - header file for the RFB protocol version 3.7
+ *
+ * Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed
+ * integer (for n = 8, 16 and 32).
+@@ -155,7 +157,8 @@
+
+ #define rfbProtocolVersionFormat "RFB %03d.%03d\n"
+ #define rfbProtocolMajorVersion 3
+-#define rfbProtocolMinorVersion 3
++#define rfbProtocolMinorVersion 7
++#define rfbProtocolFallbackMinorVersion 3
+
+ typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */
+
+@@ -163,6 +166,31 @@
+
+
+ /*-----------------------------------------------------------------------------
++ * 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"
++
++/*-----------------------------------------------------------------------------
+ * Authentication
+ *
+ * Once the protocol version has been decided, the server then sends a 32-bit
+@@ -174,6 +202,7 @@
+ #define rfbConnFailed 0
+ #define rfbNoAuth 1
+ #define rfbVncAuth 2
++#define rfbSecTypeTight 16
+
+ /*
+ * rfbConnFailed: For some reason the connection failed (e.g. the server
+@@ -201,6 +230,160 @@
+ #define rfbVncAuthFailed 1
+ #define rfbVncAuthTooMany 2
+
++/*-----------------------------------------------------------------------------
++ * 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"
++
++/* 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_"
++
++/*
++ * 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 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 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
++
++
+
+ /*-----------------------------------------------------------------------------
+ * Client Initialisation Message
+@@ -783,3 +966,5 @@
+ rfbPointerEventMsg pe;
+ rfbClientCutTextMsg cct;
+ } rfbClientToServerMsg;
++
++#endif /* VNC_RFBPROTO_H */
+diff -Nru directvnc-0.7.5/src/sockets.c directvnc-0.7.5.new/src/sockets.c
+--- directvnc-0.7.5/src/sockets.c 2003-01-31 08:33:02.000000000 +0100
++++ directvnc-0.7.5.new/src/sockets.c 2007-01-15 17:22:15.000000000 +0100
+@@ -273,3 +273,19 @@
+
+ fflush(stderr);
+ }
++
++/*
++ * Test if the other end of a socket is on the same machine.
++ */
++
++int
++SameMachine(int sock)
++{
++ struct sockaddr_in peeraddr, myaddr;
++ int addrlen = sizeof(struct sockaddr_in);
++
++ getpeername(sock, (struct sockaddr *)&peeraddr, &addrlen);
++ getsockname(sock, (struct sockaddr *)&myaddr, &addrlen);
++
++ return (peeraddr.sin_addr.s_addr == myaddr.sin_addr.s_addr);
++}
projects / packages / directvnc.git / commitdiff