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

[patch] krdc-return.patch

krdc-return.patch (text/plain), 229.07 KB, created by Roman Savochenko on 2023-11-19 15:47:03 CST

(hide)

Description: krdc-return.patch

Filename:

MIME Type:

Creator: Roman Savochenko

Created: 2023-11-19 15:47:03 CST

Size: 229.07 KB

patch

obsolete

>diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/CMakeLists.txt tdenetwork-trinity-14.1.0/krdc/CMakeLists.txt >--- tdenetwork-trinity-14.1.0-ORIG/krdc/CMakeLists.txt 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/CMakeLists.txt 2022-09-18 07:50:27.000000000 +0300 >@@ -16,8 +16,6 @@ > include_directories( > ${CMAKE_CURRENT_BINARY_DIR} > ${CMAKE_CURRENT_SOURCE_DIR} >- ${CMAKE_CURRENT_SOURCE_DIR}/../libtdevnc >- ${CMAKE_CURRENT_BINARY_DIR}/../libtdevnc > ${CMAKE_BINARY_DIR} > ${TDE_INCLUDE_DIR} > ${TQT_INCLUDE_DIRS} >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/kremoteview.h tdenetwork-trinity-14.1.0/krdc/kremoteview.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/kremoteview.h 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/kremoteview.h 2022-09-18 07:50:27.000000000 +0300 >@@ -2,8 +2,6 @@ > kremoteview.h - widget that shows the remote framebuffer > ------------------- > begin : Wed Dec 25 23:58:12 CET 2002 >- copyright : (C) 2015 by Timothy Pearson >- copyright : (C) 2007 by Urs Wolfer > copyright : (C) 2002-2003 by Tim Jansen > email : tim@tjansen.de > ***************************************************************************/ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/Makefile.am tdenetwork-trinity-14.1.0/krdc/Makefile.am >--- tdenetwork-trinity-14.1.0-ORIG/krdc/Makefile.am 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/Makefile.am 2022-09-18 07:50:27.000000000 +0300 >@@ -24,7 +24,7 @@ > dnssddata_DATA = _rfb._tcp > > krdc_LDADD = vnc/libvnc.la rdp/librdp.la $(LIB_TDEUI) $(LIBXF86VIDMODE) $(LIB_SLP) $(LIB_TDEDNSSD) $(X_LDFLAGS) $(LIB_X11) -ltdewalletclient -lDCOP >-krdc_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_TQT) -lDCOP $(LIB_TDECORE) >+krdc_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_TDECORE) > > xdg_apps_DATA = krdc.desktop > >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/rdp/Makefile.am tdenetwork-trinity-14.1.0/krdc/rdp/Makefile.am >--- tdenetwork-trinity-14.1.0-ORIG/krdc/rdp/Makefile.am 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/rdp/Makefile.am 2022-09-18 07:50:27.000000000 +0300 >@@ -8,4 +8,4 @@ > > noinst_HEADERS = krdpview.h rdphostpref.h > librdp_la_LIBADD = $(LIB_TDEUI) $(LIBJPEG) >-librdp_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_TQT) -lDCOP $(LIB_TDECORE) $(LIB_TDEUI) -ltdefx $(LIB_TDEIO) -ltdetexteditor >+librdp_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) $(LIB_QT) -lDCOP $(LIB_TDECORE) $(LIB_TDEUI) -ltdefx $(LIB_TDEIO) -ltdetexteditor >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/CMakeLists.txt tdenetwork-trinity-14.1.0/krdc/vnc/CMakeLists.txt >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/CMakeLists.txt 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/CMakeLists.txt 2022-09-18 07:50:27.000000000 +0300 >@@ -1,8 +1,5 @@ > ################################################# > # >-# (C) 2015 Timothy Pearson >-# kb9vqf (AT) pearsoncomputing (DOT) net >-# > # (C) 2010-2011 Serghei Amelian > # serghei (DOT) amelian (AT) gmail.com > # >@@ -16,9 +13,6 @@ > ${CMAKE_CURRENT_BINARY_DIR} > ${CMAKE_CURRENT_SOURCE_DIR} > ${CMAKE_CURRENT_SOURCE_DIR}/.. >- ${CMAKE_CURRENT_SOURCE_DIR}/../../libtdevnc >- ${CMAKE_CURRENT_BINARY_DIR}/../../libtdevnc >- ${CMAKE_BINARY_DIR} > ${TDE_INCLUDE_DIR} > ${TQT_INCLUDE_DIRS} > ) >@@ -28,8 +22,6 @@ > > tde_add_library( vnc STATIC_PIC AUTOMOC > SOURCES >- kvncview.cpp scaling.cpp threads.cpp >- vncprefs.ui vnchostpref.cpp >- LINK >- tdevncclient-static >+ kvncview.cpp threads.cpp colour.c d3des.c desktop.c rfbproto.c sockets.c >+ vncauth.c vncprefs.ui vnchostpref.cpp > ) >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/colour.c tdenetwork-trinity-14.1.0/krdc/vnc/colour.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/colour.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/colour.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,415 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * colour.c - functions to deal with colour - i.e. RFB pixel formats, X visuals >+ * and colormaps. Thanks to Grant McDorman for some of the ideas used here. >+ */ >+ >+#include "vncviewer.h" >+#include <limits.h> >+ >+ >+#define INVALID_PIXEL 0xffffffff >+#define MAX_CMAP_SIZE 256 >+#define BGR233_SIZE 256 >+unsigned long BGR233ToPixel[BGR233_SIZE]; >+ >+Colormap cmap; >+Visual *vis; >+unsigned int visdepth, visbpp; >+Bool allocColorFailed = False; >+ >+static int nBGR233ColoursAllocated; >+ >+static int GetBPPForDepth(int depth); >+static void SetupBGR233Map(void); >+static void AllocateExactBGR233Colours(void); >+static Bool AllocateBGR233Colour(int r, int g, int b); >+ >+ >+/* >+ * SetVisualAndCmap() deals with the wonderful world of X "visuals" (which are >+ * equivalent to the RFB protocol's "pixel format"). Having decided on the >+ * best visual, it also creates a colormap if necessary, sets the appropriate >+ * resources on the toplevel widget, and sets up the myFormat structure to >+ * describe the pixel format in terms that the RFB server will be able to >+ * understand. >+ * >+ * The algorithm for deciding which visual to use is as follows: >+ * >+ * If forceOwnCmap is true then we try to use a PseudoColor visual - we first >+ * see if there's one of the same depth as the RFB server, followed by an 8-bit >+ * deep one. >+ * >+ * If forceTrueColour is true then we try to use a TrueColor visual - if >+ * requestedDepth is set then it must be of that depth, otherwise any depth >+ * will be used. >+ * >+ * Otherwise, we use the X server's default visual and colormap. If this is >+ * TrueColor then we just ask the RFB server for this format. If the default >+ * isn't TrueColor, or if useBGR233 is true, then we ask the RFB server for >+ * BGR233 pixel format and use a lookup table to translate to the nearest >+ * colours provided by the X server. >+ */ >+ >+void >+SetVisualAndCmap() >+{ >+ /* just use default visual and colormap */ >+ >+ vis = DefaultVisual(dpy,DefaultScreen(dpy)); >+ visdepth = DefaultDepth(dpy,DefaultScreen(dpy)); >+ visbpp = GetBPPForDepth(visdepth); >+ cmap = DefaultColormap(dpy,DefaultScreen(dpy)); >+ >+ if (!appData.useBGR233 && (vis->class == TrueColor)) { >+ >+ myFormat.bitsPerPixel = visbpp; >+ myFormat.depth = visdepth; >+ myFormat.trueColour = 1; >+ myFormat.bigEndian = (ImageByteOrder(dpy) == MSBFirst); >+ myFormat.redShift = ffs(vis->red_mask) - 1; >+ myFormat.greenShift = ffs(vis->green_mask) - 1; >+ myFormat.blueShift = ffs(vis->blue_mask) - 1; >+ myFormat.redMax = vis->red_mask >> myFormat.redShift; >+ myFormat.greenMax = vis->green_mask >> myFormat.greenShift; >+ myFormat.blueMax = vis->blue_mask >> myFormat.blueShift; >+ >+ fprintf(stderr, >+ "Using default colormap which is TrueColor. Pixel format:\n"); >+ PrintPixelFormat(&myFormat); >+ return; >+ } >+ >+ appData.useBGR233 = True; >+ >+ myFormat.bitsPerPixel = 8; >+ myFormat.depth = 8; >+ myFormat.trueColour = 1; >+ myFormat.bigEndian = 0; >+ myFormat.redMax = 7; >+ myFormat.greenMax = 7; >+ myFormat.blueMax = 3; >+ myFormat.redShift = 0; >+ myFormat.greenShift = 3; >+ myFormat.blueShift = 6; >+ >+ fprintf(stderr, >+ "Using default colormap and translating from BGR233. Pixel format:\n"); >+ PrintPixelFormat(&myFormat); >+ >+ SetupBGR233Map(); >+} >+ >+ >+/* >+ * GetBPPForDepth looks through the "pixmap formats" to find the bits-per-pixel >+ * for the given depth. >+ */ >+ >+static int >+GetBPPForDepth(int depth) >+{ >+ XPixmapFormatValues *format; >+ int nformats; >+ int i; >+ int bpp; >+ >+ format = XListPixmapFormats(dpy, &nformats); >+ >+ for (i = 0; i < nformats; i++) { >+ if (format[i].depth == depth) >+ break; >+ } >+ >+ if (i == nformats) { >+ fprintf(stderr,"no pixmap format for depth %d???\n", depth); >+ exit(1); >+ } >+ >+ bpp = format[i].bits_per_pixel; >+ >+ XFree(format); >+ >+ if (bpp != 1 && bpp != 8 && bpp != 16 && bpp != 32) { >+ fprintf(stderr,"Can't cope with %d bits-per-pixel. Sorry.\n", bpp); >+ exit(1); >+ } >+ >+ return bpp; >+} >+ >+ >+ >+/* >+ * SetupBGR233Map() sets up the BGR233ToPixel array. >+ * >+ * It calls AllocateExactBGR233Colours to allocate some exact BGR233 colours >+ * (limited by space in the colormap and/or by the value of the nColours >+ * resource). If the number allocated is less than BGR233_SIZE then it fills >+ * the rest in using the "nearest" colours available. How this is done depends >+ * on the value of the useSharedColours resource. If it's false, we use only >+ * colours from the exact BGR233 colours we've just allocated. If it's true, >+ * then we also use other clients' "shared" colours available in the colormap. >+ */ >+ >+static void >+SetupBGR233Map(void) >+{ >+ int r, g, b; >+ long i; >+ unsigned long nearestPixel = 0; >+ int cmapSize; >+ XColor cmapEntry[MAX_CMAP_SIZE]; >+ Bool exactBGR233[MAX_CMAP_SIZE]; >+ Bool shared[MAX_CMAP_SIZE]; >+ Bool usedAsNearest[MAX_CMAP_SIZE]; >+ int nSharedUsed = 0; >+ >+ if (visdepth > 8) { >+ appData.nColours = 256; /* ignore nColours setting for > 8-bit deep */ >+ } >+ >+ for (i = 0; i < BGR233_SIZE; i++) { >+ BGR233ToPixel[i] = INVALID_PIXEL; >+ } >+ >+ AllocateExactBGR233Colours(); >+ >+ fprintf(stderr,"Got %d exact BGR233 colours out of %d\n", >+ nBGR233ColoursAllocated, appData.nColours); >+ >+ if (nBGR233ColoursAllocated < BGR233_SIZE) { >+ >+ if (visdepth > 8) { /* shouldn't get here */ >+ fprintf(stderr,"Error: couldn't allocate BGR233 colours even though " >+ "depth is %d\n", visdepth); >+ exit(1); >+ } >+ >+ cmapSize = (1 << visdepth); >+ >+ for (i = 0; i < cmapSize; i++) { >+ cmapEntry[i].pixel = i; >+ exactBGR233[i] = False; >+ shared[i] = False; >+ usedAsNearest[i] = False; >+ } >+ >+ XQueryColors(dpy, cmap, cmapEntry, cmapSize); >+ >+ /* mark all our exact BGR233 pixels */ >+ >+ for (i = 0; i < BGR233_SIZE; i++) { >+ if (BGR233ToPixel[i] != INVALID_PIXEL) >+ exactBGR233[BGR233ToPixel[i]] = True; >+ } >+ >+ if (appData.useSharedColours) { >+ >+ /* Try to find existing shared colours. This is harder than it sounds >+ because XQueryColors doesn't tell us whether colours are shared, >+ private or unallocated. What we do is go through the colormap and for >+ each pixel try to allocate exactly its RGB values. If this returns a >+ different pixel then it's definitely either a private or unallocated >+ pixel, so no use to us. If it returns us the same pixel again, then >+ it's likely that it's a shared colour - however, it is possible that >+ it was actually an unallocated pixel, which we've now allocated. We >+ minimise this possibility by going through the pixels in reverse order >+ - this helps becuse the X server allocates new pixels from the lowest >+ number up, so it should only be a problem for the lowest unallocated >+ pixel. Got that? */ >+ >+ for (i = cmapSize-1; i >= 0; i--) { >+ if (!exactBGR233[i] && >+ XAllocColor(dpy, cmap, &cmapEntry[i])) { >+ >+ if (cmapEntry[i].pixel == (unsigned long) i) { >+ >+ shared[i] = True; /* probably shared */ >+ >+ } else { >+ >+ /* "i" is either unallocated or private. We have now unnecessarily >+ allocated cmapEntry[i].pixel. Free it. */ >+ >+ XFreeColors(dpy, cmap, &cmapEntry[i].pixel, 1, 0); >+ } >+ } >+ } >+ } >+ >+ /* Now fill in the nearest colours */ >+ >+ for (r = 0; r < 8; r++) { >+ for (g = 0; g < 8; g++) { >+ for (b = 0; b < 4; b++) { >+ if (BGR233ToPixel[(b<<6) | (g<<3) | r] == INVALID_PIXEL) { >+ >+ unsigned long minDistance = ULONG_MAX; >+ >+ for (i = 0; i < cmapSize; i++) { >+ if (exactBGR233[i] || shared[i]) { >+ unsigned long distance >+ = (abs(cmapEntry[i].red - r * 65535 / 7) >+ + abs(cmapEntry[i].green - g * 65535 / 7) >+ + abs(cmapEntry[i].blue - b * 65535 / 3)); >+ >+ if (distance < minDistance) { >+ minDistance = distance; >+ nearestPixel = i; >+ } >+ } >+ } >+ >+ BGR233ToPixel[(b<<6) | (g<<3) | r] = nearestPixel; >+ if (shared[nearestPixel] && !usedAsNearest[nearestPixel]) >+ nSharedUsed++; >+ usedAsNearest[nearestPixel] = True; >+ } >+ } >+ } >+ } >+ >+ /* Tidy up shared colours which we allocated but aren't going to use */ >+ >+ for (i = 0; i < cmapSize; i++) { >+ if (shared[i] && !usedAsNearest[i]) { >+ XFreeColors(dpy, cmap, (unsigned long *)&i, 1, 0); >+ } >+ } >+ >+ fprintf(stderr,"Using %d existing shared colours\n", nSharedUsed); >+ } >+} >+ >+ >+/* >+ * AllocateExactBGR233Colours() attempts to allocate each of the colours in the >+ * BGR233 colour cube, stopping when an allocation fails. The order it does >+ * this in is such that we should get a fairly well spread subset of the cube, >+ * however many allocations are made. There's probably a neater algorithm for >+ * doing this, but it's not obvious to me anyway. The way this algorithm works >+ * is: >+ * >+ * At each stage, we introduce a new value for one of the primaries, and >+ * allocate all the colours with the new value of that primary and all previous >+ * values of the other two primaries. We start with r=0 as the "new" value >+ * for r, and g=0, b=0 as the "previous" values of g and b. So we get: >+ * >+ * New primary value Previous values of other primaries Colours allocated >+ * ----------------- ---------------------------------- ----------------- >+ * r=0 g=0 b=0 r0 g0 b0 >+ * g=7 r=0 b=0 r0 g7 b0 >+ * b=3 r=0 g=0,7 r0 g0 b3 >+ * r0 g7 b3 >+ * r=7 g=0,7 b=0,3 r7 g0 b0 >+ * r7 g0 b3 >+ * r7 g7 b0 >+ * r7 g7 b3 >+ * g=3 r=0,7 b=0,3 r0 g3 b0 >+ * r0 g3 b3 >+ * r7 g3 b0 >+ * r7 g3 b3 >+ * ....etc. >+ * */ >+ >+static void >+AllocateExactBGR233Colours(void) >+{ >+ int rv[] = {0,7,3,5,1,6,2,4}; >+ int gv[] = {0,7,3,5,1,6,2,4}; >+ int bv[] = {0,3,1,2}; >+ int rn = 0; >+ int gn = 1; >+ int bn = 1; >+ int ri, gi, bi; >+ >+ nBGR233ColoursAllocated = 0; >+ >+ while (1) { >+ if (rn == 8) >+ break; >+ >+ ri = rn; >+ for (gi = 0; gi < gn; gi++) { >+ for (bi = 0; bi < bn; bi++) { >+ if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi])) >+ return; >+ } >+ } >+ rn++; >+ >+ if (gn == 8) >+ break; >+ >+ gi = gn; >+ for (ri = 0; ri < rn; ri++) { >+ for (bi = 0; bi < bn; bi++) { >+ if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi])) >+ return; >+ } >+ } >+ gn++; >+ >+ if (bn < 4) { >+ >+ bi = bn; >+ for (ri = 0; ri < rn; ri++) { >+ for (gi = 0; gi < gn; gi++) { >+ if (!AllocateBGR233Colour(rv[ri], gv[gi], bv[bi])) >+ return; >+ } >+ } >+ bn++; >+ } >+ } >+} >+ >+ >+/* >+ * AllocateBGR233Colour() attempts to allocate the given BGR233 colour as a >+ * shared colormap entry, storing its pixel value in the BGR233ToPixel array. >+ * r is from 0 to 7, g from 0 to 7 and b from 0 to 3. It fails either when the >+ * allocation fails or when we would exceed the number of colours specified in >+ * the nColours resource. >+ */ >+ >+static Bool >+AllocateBGR233Colour(int r, int g, int b) >+{ >+ XColor c; >+ >+ if (nBGR233ColoursAllocated >= appData.nColours) >+ return False; >+ >+ c.red = r * 65535 / 7; >+ c.green = g * 65535 / 7; >+ c.blue = b * 65535 / 3; >+ >+ if (!XAllocColor(dpy, cmap, &c)) >+ return False; >+ >+ BGR233ToPixel[(b<<6) | (g<<3) | r] = c.pixel; >+ >+ nBGR233ColoursAllocated++; >+ >+ return True; >+} >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/d3des.c tdenetwork-trinity-14.1.0/krdc/vnc/d3des.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/d3des.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/d3des.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,440 @@ >+/* >+ * This is D3DES (V5.09) by Richard Outerbridge with the double and >+ * triple-length support removed for use in VNC. Also the bytebit[] array >+ * has been reversed so that the most significant bit in each byte of the >+ * key is ignored, not the least significant. >+ * >+ * These changes are: >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. >+ */ >+ >+/* D3DES (V5.09) - >+ * >+ * A portable, public domain, version of the Data Encryption Standard. >+ * >+ * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge. >+ * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation >+ * code; Jim Gillogly & Phil Karn for the DES key schedule code; Dennis >+ * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau, >+ * for humouring me on. >+ * >+ * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge. >+ * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992. >+ */ >+ >+#include "d3des.h" >+ >+static void scrunch(unsigned char *, unsigned long *); >+static void unscrun(unsigned long *, unsigned char *); >+static void desfunc(unsigned long *, unsigned long *); >+static void cookey(unsigned long *); >+ >+static unsigned long KnL[32] = { 0L }; >+static unsigned long KnR[32] = { 0L }; >+static unsigned long Kn3[32] = { 0L }; >+static unsigned char Df_Key[24] = { >+ 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef, >+ 0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10, >+ 0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67 }; >+ >+static unsigned short bytebit[8] = { >+ 01, 02, 04, 010, 020, 040, 0100, 0200 }; >+ >+static unsigned long bigbyte[24] = { >+ 0x800000L, 0x400000L, 0x200000L, 0x100000L, >+ 0x80000L, 0x40000L, 0x20000L, 0x10000L, >+ 0x8000L, 0x4000L, 0x2000L, 0x1000L, >+ 0x800L, 0x400L, 0x200L, 0x100L, >+ 0x80L, 0x40L, 0x20L, 0x10L, >+ 0x8L, 0x4L, 0x2L, 0x1L }; >+ >+/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */ >+ >+static unsigned char pc1[56] = { >+ 56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, >+ 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, >+ 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, >+ 13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3 }; >+ >+static unsigned char totrot[16] = { >+ 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 }; >+ >+static unsigned char pc2[48] = { >+ 13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, >+ 22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1, >+ 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47, >+ 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 }; >+ >+void deskey(key, edf) /* Thanks to James Gillogly & Phil Karn! */ >+unsigned char *key; >+int edf; >+{ >+ register int i, j, l, m, n; >+ unsigned char pc1m[56], pcr[56]; >+ unsigned long kn[32]; >+ >+ for ( j = 0; j < 56; j++ ) { >+ l = pc1[j]; >+ m = l & 07; >+ pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0; >+ } >+ for( i = 0; i < 16; i++ ) { >+ if( edf == DE1 ) m = (15 - i) << 1; >+ else m = i << 1; >+ n = m + 1; >+ kn[m] = kn[n] = 0L; >+ for( j = 0; j < 28; j++ ) { >+ l = j + totrot[i]; >+ if( l < 28 ) pcr[j] = pc1m[l]; >+ else pcr[j] = pc1m[l - 28]; >+ } >+ for( j = 28; j < 56; j++ ) { >+ l = j + totrot[i]; >+ if( l < 56 ) pcr[j] = pc1m[l]; >+ else pcr[j] = pc1m[l - 28]; >+ } >+ for( j = 0; j < 24; j++ ) { >+ if( pcr[pc2[j]] ) kn[m] |= bigbyte[j]; >+ if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j]; >+ } >+ } >+ cookey(kn); >+ return; >+ } >+ >+static void cookey(raw1) >+register unsigned long *raw1; >+{ >+ register unsigned long *cook, *raw0; >+ unsigned long dough[32]; >+ register int i; >+ >+ cook = dough; >+ for( i = 0; i < 16; i++, raw1++ ) { >+ raw0 = raw1++; >+ *cook = (*raw0 & 0x00fc0000L) << 6; >+ *cook |= (*raw0 & 0x00000fc0L) << 10; >+ *cook |= (*raw1 & 0x00fc0000L) >> 10; >+ *cook++ |= (*raw1 & 0x00000fc0L) >> 6; >+ *cook = (*raw0 & 0x0003f000L) << 12; >+ *cook |= (*raw0 & 0x0000003fL) << 16; >+ *cook |= (*raw1 & 0x0003f000L) >> 4; >+ *cook++ |= (*raw1 & 0x0000003fL); >+ } >+ usekey(dough); >+ return; >+ } >+ >+void cpkey(into) >+register unsigned long *into; >+{ >+ register unsigned long *from, *endp; >+ >+ from = KnL, endp = &KnL[32]; >+ while( from < endp ) *into++ = *from++; >+ return; >+ } >+ >+void usekey(from) >+register unsigned long *from; >+{ >+ register unsigned long *to, *endp; >+ >+ to = KnL, endp = &KnL[32]; >+ while( to < endp ) *to++ = *from++; >+ return; >+ } >+ >+void des(inblock, outblock) >+unsigned char *inblock, *outblock; >+{ >+ unsigned long work[2]; >+ >+ scrunch(inblock, work); >+ desfunc(work, KnL); >+ unscrun(work, outblock); >+ return; >+ } >+ >+static void scrunch(outof, into) >+register unsigned char *outof; >+register unsigned long *into; >+{ >+ *into = (*outof++ & 0xffL) << 24; >+ *into |= (*outof++ & 0xffL) << 16; >+ *into |= (*outof++ & 0xffL) << 8; >+ *into++ |= (*outof++ & 0xffL); >+ *into = (*outof++ & 0xffL) << 24; >+ *into |= (*outof++ & 0xffL) << 16; >+ *into |= (*outof++ & 0xffL) << 8; >+ *into |= (*outof & 0xffL); >+ return; >+ } >+ >+static void unscrun(outof, into) >+register unsigned long *outof; >+register unsigned char *into; >+{ >+ *into++ = (*outof >> 24) & 0xffL; >+ *into++ = (*outof >> 16) & 0xffL; >+ *into++ = (*outof >> 8) & 0xffL; >+ *into++ = *outof++ & 0xffL; >+ *into++ = (*outof >> 24) & 0xffL; >+ *into++ = (*outof >> 16) & 0xffL; >+ *into++ = (*outof >> 8) & 0xffL; >+ *into = *outof & 0xffL; >+ return; >+ } >+ >+static unsigned long SP1[64] = { >+ 0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L, >+ 0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L, >+ 0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L, >+ 0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L, >+ 0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L, >+ 0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L, >+ 0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L, >+ 0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L, >+ 0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L, >+ 0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L, >+ 0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L, >+ 0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L, >+ 0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L, >+ 0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L, >+ 0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L, >+ 0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L }; >+ >+static unsigned long SP2[64] = { >+ 0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L, >+ 0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L, >+ 0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L, >+ 0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L, >+ 0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L, >+ 0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L, >+ 0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L, >+ 0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L, >+ 0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L, >+ 0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L, >+ 0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L, >+ 0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L, >+ 0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L, >+ 0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L, >+ 0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L, >+ 0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L }; >+ >+static unsigned long SP3[64] = { >+ 0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L, >+ 0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L, >+ 0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L, >+ 0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L, >+ 0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L, >+ 0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L, >+ 0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L, >+ 0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L, >+ 0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L, >+ 0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L, >+ 0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L, >+ 0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L, >+ 0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L, >+ 0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L, >+ 0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L, >+ 0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L }; >+ >+static unsigned long SP4[64] = { >+ 0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L, >+ 0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L, >+ 0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L, >+ 0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L, >+ 0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L, >+ 0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L, >+ 0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L, >+ 0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L, >+ 0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L, >+ 0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L, >+ 0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L, >+ 0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L, >+ 0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L, >+ 0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L, >+ 0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L, >+ 0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L }; >+ >+static unsigned long SP5[64] = { >+ 0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L, >+ 0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L, >+ 0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L, >+ 0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L, >+ 0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L, >+ 0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L, >+ 0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L, >+ 0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L, >+ 0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L, >+ 0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L, >+ 0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L, >+ 0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L, >+ 0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L, >+ 0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L, >+ 0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L, >+ 0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L }; >+ >+static unsigned long SP6[64] = { >+ 0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L, >+ 0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L, >+ 0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L, >+ 0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L, >+ 0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L, >+ 0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L, >+ 0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L, >+ 0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L, >+ 0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L, >+ 0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L, >+ 0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L, >+ 0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L, >+ 0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L, >+ 0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L, >+ 0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L, >+ 0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L }; >+ >+static unsigned long SP7[64] = { >+ 0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L, >+ 0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L, >+ 0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L, >+ 0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L, >+ 0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L, >+ 0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L, >+ 0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L, >+ 0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L, >+ 0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L, >+ 0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L, >+ 0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L, >+ 0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L, >+ 0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L, >+ 0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L, >+ 0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L, >+ 0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L }; >+ >+static unsigned long SP8[64] = { >+ 0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L, >+ 0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L, >+ 0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L, >+ 0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L, >+ 0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L, >+ 0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L, >+ 0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L, >+ 0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L, >+ 0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L, >+ 0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L, >+ 0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L, >+ 0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L, >+ 0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L, >+ 0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L, >+ 0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L, >+ 0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L }; >+ >+static void desfunc(block, keys) >+register unsigned long *block, *keys; >+{ >+ register unsigned long fval, work, right, leftt; >+ register int round; >+ >+ leftt = block[0]; >+ right = block[1]; >+ work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL; >+ right ^= work; >+ leftt ^= (work << 4); >+ work = ((leftt >> 16) ^ right) & 0x0000ffffL; >+ right ^= work; >+ leftt ^= (work << 16); >+ work = ((right >> 2) ^ leftt) & 0x33333333L; >+ leftt ^= work; >+ right ^= (work << 2); >+ work = ((right >> 8) ^ leftt) & 0x00ff00ffL; >+ leftt ^= work; >+ right ^= (work << 8); >+ right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL; >+ work = (leftt ^ right) & 0xaaaaaaaaL; >+ leftt ^= work; >+ right ^= work; >+ leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL; >+ >+ for( round = 0; round < 8; round++ ) { >+ work = (right << 28) | (right >> 4); >+ work ^= *keys++; >+ fval = SP7[ work & 0x3fL]; >+ fval |= SP5[(work >> 8) & 0x3fL]; >+ fval |= SP3[(work >> 16) & 0x3fL]; >+ fval |= SP1[(work >> 24) & 0x3fL]; >+ work = right ^ *keys++; >+ fval |= SP8[ work & 0x3fL]; >+ fval |= SP6[(work >> 8) & 0x3fL]; >+ fval |= SP4[(work >> 16) & 0x3fL]; >+ fval |= SP2[(work >> 24) & 0x3fL]; >+ leftt ^= fval; >+ work = (leftt << 28) | (leftt >> 4); >+ work ^= *keys++; >+ fval = SP7[ work & 0x3fL]; >+ fval |= SP5[(work >> 8) & 0x3fL]; >+ fval |= SP3[(work >> 16) & 0x3fL]; >+ fval |= SP1[(work >> 24) & 0x3fL]; >+ work = leftt ^ *keys++; >+ fval |= SP8[ work & 0x3fL]; >+ fval |= SP6[(work >> 8) & 0x3fL]; >+ fval |= SP4[(work >> 16) & 0x3fL]; >+ fval |= SP2[(work >> 24) & 0x3fL]; >+ right ^= fval; >+ } >+ >+ right = (right << 31) | (right >> 1); >+ work = (leftt ^ right) & 0xaaaaaaaaL; >+ leftt ^= work; >+ right ^= work; >+ leftt = (leftt << 31) | (leftt >> 1); >+ work = ((leftt >> 8) ^ right) & 0x00ff00ffL; >+ right ^= work; >+ leftt ^= (work << 8); >+ work = ((leftt >> 2) ^ right) & 0x33333333L; >+ right ^= work; >+ leftt ^= (work << 2); >+ work = ((right >> 16) ^ leftt) & 0x0000ffffL; >+ leftt ^= work; >+ right ^= (work << 16); >+ work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL; >+ leftt ^= work; >+ right ^= (work << 4); >+ *block++ = right; >+ *block = leftt; >+ return; >+ } >+ >+/* Validation sets: >+ * >+ * Single-length key, single-length plaintext - >+ * Key : 0123 4567 89ab cdef >+ * Plain : 0123 4567 89ab cde7 >+ * Cipher : c957 4425 6a5e d31d >+ * >+ * Double-length key, single-length plaintext - >+ * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 >+ * Plain : 0123 4567 89ab cde7 >+ * Cipher : 7f1d 0a77 826b 8aff >+ * >+ * Double-length key, double-length plaintext - >+ * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 >+ * Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff >+ * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7 >+ * >+ * Triple-length key, single-length plaintext - >+ * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567 >+ * Plain : 0123 4567 89ab cde7 >+ * Cipher : de0b 7c06 ae5e 0ed5 >+ * >+ * Triple-length key, double-length plaintext - >+ * Key : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567 >+ * Plain : 0123 4567 89ab cdef 0123 4567 89ab cdff >+ * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5 >+ * >+ * d3des V5.0a rwo 9208.07 18:44 Graven Imagery >+ **********************************************************************/ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/d3des.h tdenetwork-trinity-14.1.0/krdc/vnc/d3des.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/d3des.h 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/d3des.h 2022-09-18 07:50:27.000000000 +0300 >@@ -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 -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/desktop.c tdenetwork-trinity-14.1.0/krdc/vnc/desktop.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/desktop.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/desktop.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,1613 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * Copyright (C) 2002 Tim Jansen. All Rights Reserved. >+ * Copyright (C) 1999-2001 Anders Lindstr�m >+ * >+ * >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ * >+ * tim@tjansen.de: - removed stuff for krdc >+ * - merged with shm.c and misc.c >+ * - added FillRectangle and Sync methods to draw only on >+ * the image >+ * - added Zoom functionality, based on rotation funcs from >+ * SGE by Anders Lindstr�m) >+ * - added support for softcursor encoding >+ * >+ */ >+ >+/* >+ * desktop.c - functions to deal with "desktop" window. >+ */ >+ >+#include <X11/Xlib.h> >+#include <sys/ipc.h> >+#include <sys/shm.h> >+#include <X11/extensions/XShm.h> >+#include <math.h> >+#include <limits.h> >+#include "vncviewer.h" >+ >+static XShmSegmentInfo shminfo; >+static Bool caughtShmError = False; >+static Bool needShmCleanup = False; >+ >+static XShmSegmentInfo zoomshminfo; >+static Bool caughtZoomShmError = False; >+static Bool needZoomShmCleanup = False; >+ >+static Bool gcInited = False; >+GC gc; >+GC srcGC, dstGC; /* used for debugging copyrect */ >+Dimension dpyWidth, dpyHeight; >+ >+static XImage *image = NULL; >+Bool useShm = True; >+ >+static Bool zoomActive = False; >+static int zoomWidth, zoomHeight; >+static XImage *zoomImage = NULL; >+static Bool useZoomShm = True; >+ >+/* for softcursor */ >+static char *savedArea = NULL; >+ >+typedef enum { >+ SOFTCURSOR_UNDER, >+ SOFTCURSOR_PART_UNDER, >+ SOFTCURSOR_UNAFFECTED >+} SoftCursorState; >+ >+typedef int Sint32; >+typedef short Sint16; >+typedef char Sint8; >+typedef unsigned int Uint32; >+typedef unsigned short Uint16; >+typedef unsigned char Uint8; >+ >+typedef struct { >+ int w, h; >+ unsigned int pitch; >+ void *pixels; >+ int BytesPerPixel; >+} Surface; >+ >+typedef struct { >+ Sint16 x, y; >+ Uint16 w, h; >+} Rect; >+ >+static void bgr233cpy(CARD8 *dst, CARD8 *src, int len); >+static void CopyDataToScreenRaw(char *buf, int x, int y, int width, int height); >+static void CopyBGR233ToScreen(CARD8 *buf, int x, int y, int width,int height); >+static void FillRectangleBGR233(CARD8 buf, int x, int y, int width,int height); >+static int CheckRectangle(int x, int y, int width, int height); >+static SoftCursorState getSoftCursorState(int x, int y, int width, int height); >+static void discardCursorSavedArea(void); >+static void saveCursorSavedArea(void); >+ >+static void ZoomInit(void); >+static void transformZoomSrc(int six, int siy, int siw, int sih, >+ int *dix, int *diy, int *diw, int *dih, >+ int srcW, int dstW, int srcH, int dstH); >+static void transformZoomDst(int *six, int *siy, int *siw, int *sih, >+ int dix, int diy, int diw, int dih, >+ int srcW, int dstW, int srcH, int dstH); >+static void ZoomSurfaceSrcCoords(int x, int y, int w, int h, >+ int *dix, int *diy, int *diw, int *dih, >+ Surface * src, Surface * dst); >+static void ZoomSurfaceCoords32(int sx, int sy, int sw, int sh, >+ int dx, int dy, Surface * src, Surface * dst); >+static void sge_transform(Surface *src, Surface *dst, float xscale, float yscale, >+ Uint16 qx, Uint16 qy); >+ >+ >+void >+DesktopInit(Window win) >+{ >+ XGCValues gcv; >+ >+ image = CreateShmImage(); >+ >+ if (!image) { >+ useShm = False; >+ image = XCreateImage(dpy, vis, visdepth, ZPixmap, 0, NULL, >+ si.framebufferWidth, si.framebufferHeight, >+ BitmapPad(dpy), 0); >+ >+ image->data = calloc(image->bytes_per_line * image->height, 1); >+ if (!image->data) { >+ fprintf(stderr,"malloc failed\n"); >+ exit(1); >+ } >+ } >+ >+ gc = XCreateGC(dpy,win,0,NULL); >+ >+ gcv.function = GXxor; >+ gcv.foreground = 0x0f0f0f0f; >+ srcGC = XCreateGC(dpy,win,GCFunction|GCForeground,&gcv); >+ gcv.foreground = 0xf0f0f0f0; >+ dstGC = XCreateGC(dpy,win,GCFunction|GCForeground,&gcv); >+ gcInited = True; >+} >+ >+/* >+ * DrawScreenRegionX11Thread >+ * Never call from any other desktop.c function, only for X11 thread >+ */ >+ >+void >+DrawScreenRegionX11Thread(Window win, int x, int y, int width, int height) { >+ zoomActive = False; >+ zoomWidth = 0; >+ zoomHeight = 0; >+ >+ if (!image) >+ return; >+ >+ if (useShm) >+ XShmPutImage(dpy, win, gc, image, x, y, x, y, width, height, False); >+ else >+ XPutImage(dpy, win, gc, image, x, y, x, y, width, height); >+} >+ >+/* >+ * CheckRectangle >+ */ >+ >+static int CheckRectangle(int x, int y, int width, int height) { >+ if ((x < 0) || (y < 0)) >+ return 0; >+ >+ if (((x+width) > si.framebufferWidth) || ((y+height) > si.framebufferHeight)) >+ return 0; >+ >+ return 1; >+} >+ >+static >+void bgr233cpy(CARD8 *dst, CARD8 *src, int len) { >+ int i; >+ CARD16 *d16; >+ CARD32 *d32; >+ >+ switch (visbpp) { >+ case 8: >+ for (i = 0; i < len; i++) >+ *(dst++) = (CARD8) BGR233ToPixel[*(src++)]; >+ break; >+ case 16: >+ d16 = (CARD16*) dst; >+ for (i = 0; i < len; i++) >+ *(d16++) = (CARD16) BGR233ToPixel[*(src++)]; >+ break; >+ case 32: >+ d32 = (CARD32*) dst; >+ for (i = 0; i < len; i++) >+ *(d32++) = (CARD32) BGR233ToPixel[*(src++)]; >+ break; >+ default: >+ fprintf(stderr, "Unsupported softcursor depth %d\n", visbpp); >+ } >+} >+ >+ >+/* >+ * CopyDataToScreen. >+ */ >+ >+void >+CopyDataToScreen(char *buf, int x, int y, int width, int height) >+{ >+ SoftCursorState s; >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ LockFramebuffer(); >+ s = getSoftCursorState(x, y, width, height); >+ if (s == SOFTCURSOR_PART_UNDER) >+ undrawCursor(); >+ >+ if (!appData.useBGR233) >+ CopyDataToScreenRaw(buf, x, y, width, height); >+ else >+ CopyBGR233ToScreen((CARD8 *)buf, x, y, width, height); >+ >+ if (s != SOFTCURSOR_UNAFFECTED) >+ drawCursor(); >+ >+ UnlockFramebuffer(); >+ SyncScreenRegion(x, y, width, height); >+} >+ >+/* >+ * CopyDataToScreenRaw. >+ */ >+ >+static void >+CopyDataToScreenRaw(char *buf, int x, int y, int width, int height) >+{ >+ int h; >+ int widthInBytes = width * visbpp / 8; >+ int scrWidthInBytes = image->bytes_per_line; >+ char *scr = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ >+ for (h = 0; h < height; h++) { >+ memcpy(scr, buf, widthInBytes); >+ buf += widthInBytes; >+ scr += scrWidthInBytes; >+ } >+} >+ >+/* >+ * CopyBGR233ToScreen. >+ */ >+ >+static void >+CopyBGR233ToScreen(CARD8 *buf, int x, int y, int width, int height) >+{ >+ int p, q; >+ int xoff = 7 - (x & 7); >+ int xcur; >+ int fbwb = si.framebufferWidth / 8; >+ CARD8 *scr1 = ((CARD8 *)image->data) + y * fbwb + x / 8; >+ CARD8 *scrt; >+ CARD8 *scr8 = ((CARD8 *)image->data) + y * si.framebufferWidth + x; >+ CARD16 *scr16 = ((CARD16 *)image->data) + y * si.framebufferWidth + x; >+ CARD32 *scr32 = ((CARD32 *)image->data) + y * si.framebufferWidth + x; >+ >+ switch (visbpp) { >+ >+ /* thanks to Chris Hooper for single bpp support */ >+ >+ case 1: >+ for (q = 0; q < height; q++) { >+ xcur = xoff; >+ scrt = scr1; >+ for (p = 0; p < width; p++) { >+ *scrt = ((*scrt & ~(1 << xcur)) >+ | (BGR233ToPixel[*(buf++)] << xcur)); >+ >+ if (xcur-- == 0) { >+ xcur = 7; >+ scrt++; >+ } >+ } >+ scr1 += fbwb; >+ } >+ break; >+ >+ case 8: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr8++) = BGR233ToPixel[*(buf++)]; >+ } >+ scr8 += si.framebufferWidth - width; >+ } >+ break; >+ >+ case 16: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr16++) = BGR233ToPixel[*(buf++)]; >+ } >+ scr16 += si.framebufferWidth - width; >+ } >+ break; >+ >+ case 32: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr32++) = BGR233ToPixel[*(buf++)]; >+ } >+ scr32 += si.framebufferWidth - width; >+ } >+ break; >+ } >+} >+ >+/* >+ * FillRectangle8. >+ */ >+ >+void >+FillRectangle8(CARD8 fg, int x, int y, int width, int height) >+{ >+ SoftCursorState s; >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ s = getSoftCursorState(x, y, width, height); >+ if (s == SOFTCURSOR_PART_UNDER) >+ undrawCursor(); >+ >+ if (!appData.useBGR233) { >+ int h; >+ int widthInBytes = width * visbpp / 8; >+ int scrWidthInBytes = image->bytes_per_line; >+ >+ char *scr = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ >+ for (h = 0; h < height; h++) { >+ memset(scr, fg, widthInBytes); >+ scr += scrWidthInBytes; >+ } >+ } else { >+ FillRectangleBGR233(fg, x, y, width, height); >+ } >+ >+ if (s != SOFTCURSOR_UNAFFECTED) >+ drawCursor(); >+} >+ >+/* >+ * FillRectangleBGR233. >+ */ >+ >+static void >+FillRectangleBGR233(CARD8 fg, int x, int y, int width, int height) >+{ >+ int p, q; >+ int xoff = 7 - (x & 7); >+ int xcur; >+ int fbwb = si.framebufferWidth / 8; >+ CARD8 *scr1 = ((CARD8 *)image->data) + y * fbwb + x / 8; >+ CARD8 *scrt; >+ CARD8 *scr8 = ((CARD8 *)image->data) + y * si.framebufferWidth + x; >+ CARD16 *scr16 = ((CARD16 *)image->data) + y * si.framebufferWidth + x; >+ CARD32 *scr32 = ((CARD32 *)image->data) + y * si.framebufferWidth + x; >+ >+ unsigned long fg233 = BGR233ToPixel[fg]; >+ >+ switch (visbpp) { >+ >+ /* thanks to Chris Hooper for single bpp support */ >+ >+ case 1: >+ for (q = 0; q < height; q++) { >+ xcur = xoff; >+ scrt = scr1; >+ for (p = 0; p < width; p++) { >+ *scrt = ((*scrt & ~(1 << xcur)) >+ | (fg233 << xcur)); >+ >+ if (xcur-- == 0) { >+ xcur = 7; >+ scrt++; >+ } >+ } >+ scr1 += fbwb; >+ } >+ break; >+ >+ case 8: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr8++) = fg233; >+ } >+ scr8 += si.framebufferWidth - width; >+ } >+ break; >+ >+ case 16: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr16++) = fg233; >+ } >+ scr16 += si.framebufferWidth - width; >+ } >+ break; >+ >+ case 32: >+ for (q = 0; q < height; q++) { >+ for (p = 0; p < width; p++) { >+ *(scr32++) = fg233; >+ } >+ scr32 += si.framebufferWidth - width; >+ } >+ break; >+ } >+} >+ >+/* >+ * FillRectangle16 >+ */ >+ >+void >+FillRectangle16(CARD16 fg, int x, int y, int width, int height) >+{ >+ int i, h; >+ int scrWidthInBytes = image->bytes_per_line; >+ >+ char *scr = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ CARD16 *scr16; >+ SoftCursorState s; >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ s = getSoftCursorState(x, y, width, height); >+ if (s == SOFTCURSOR_PART_UNDER) >+ undrawCursor(); >+ >+ for (h = 0; h < height; h++) { >+ scr16 = (CARD16*) scr; >+ for (i = 0; i < width; i++) >+ scr16[i] = fg; >+ scr += scrWidthInBytes; >+ } >+ >+ if (s != SOFTCURSOR_UNAFFECTED) >+ drawCursor(); >+} >+ >+/* >+ * FillRectangle32 >+ */ >+ >+void >+FillRectangle32(CARD32 fg, int x, int y, int width, int height) >+{ >+ int i, h; >+ int scrWidthInBytes = image->bytes_per_line; >+ SoftCursorState s; >+ >+ char *scr = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ CARD32 *scr32; >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ s = getSoftCursorState(x, y, width, height); >+ if (s == SOFTCURSOR_PART_UNDER) >+ undrawCursor(); >+ >+ for (h = 0; h < height; h++) { >+ scr32 = (CARD32*) scr; >+ for (i = 0; i < width; i++) >+ scr32[i] = fg; >+ scr += scrWidthInBytes; >+ } >+ >+ if (s != SOFTCURSOR_UNAFFECTED) >+ drawCursor(); >+} >+ >+/* >+ * CopyDataFromScreen. >+ */ >+ >+void >+CopyDataFromScreen(char *buf, int x, int y, int width, int height) >+{ >+ int widthInBytes = width * visbpp / 8; >+ int scrWidthInBytes = image->bytes_per_line; >+ char *src = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ int h; >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ for (h = 0; h < height; h++) { >+ memcpy(buf, src, widthInBytes); >+ src += scrWidthInBytes; >+ buf += widthInBytes; >+ } >+} >+ >+/* >+ * CopyArea >+ */ >+ >+void >+CopyArea(int srcX, int srcY, int width, int height, int x, int y) >+{ >+ int widthInBytes = width * visbpp / 8; >+ SoftCursorState sSrc, sDst; >+ >+ LockFramebuffer(); >+ sSrc = getSoftCursorState(srcX, srcY, width, height); >+ sDst = getSoftCursorState(x, y, width, height); >+ if ((sSrc != SOFTCURSOR_UNAFFECTED) || >+ (sDst == SOFTCURSOR_PART_UNDER)) >+ undrawCursor(); >+ >+ if ((srcY+height < y) || (y+height < srcY) || >+ (srcX+width < x) || (x+width < srcX)) { >+ >+ int scrWidthInBytes = image->bytes_per_line; >+ char *src = (image->data + srcY * scrWidthInBytes >+ + srcX * visbpp / 8); >+ char *dst = (image->data + y * scrWidthInBytes >+ + x * visbpp / 8); >+ int h; >+ >+ if (!CheckRectangle(srcX, srcY, width, height)) { >+ UnlockFramebuffer(); >+ return; >+ } >+ if (!CheckRectangle(x, y, width, height)) { >+ UnlockFramebuffer(); >+ return; >+ } >+ >+ for (h = 0; h < height; h++) { >+ memcpy(dst, src, widthInBytes); >+ src += scrWidthInBytes; >+ dst += scrWidthInBytes; >+ } >+ } >+ else { >+ char *buf = malloc(widthInBytes*height); >+ if (!buf) { >+ UnlockFramebuffer(); >+ fprintf(stderr, "Out of memory, CopyArea impossible\n"); >+ return; >+ } >+ CopyDataFromScreen(buf, srcX, srcY, width, height); >+ CopyDataToScreenRaw(buf, x, y, width, height); >+ free(buf); >+ } >+ if ((sSrc != SOFTCURSOR_UNAFFECTED) || >+ (sDst != SOFTCURSOR_UNAFFECTED)) >+ drawCursor(); >+ UnlockFramebuffer(); >+ SyncScreenRegion(x, y, width, height); >+} >+ >+void SyncScreenRegion(int x, int y, int width, int height) { >+ int dx, dy, dw, dh; >+ >+ if (zoomActive) { >+ Surface src, dest; >+ src.w = si.framebufferWidth; >+ src.h = si.framebufferHeight; >+ src.pitch = image->bytes_per_line; >+ src.pixels = image->data; >+ src.BytesPerPixel = visbpp / 8; >+ dest.w = zoomWidth; >+ dest.h = zoomHeight; >+ dest.pitch = zoomImage->bytes_per_line; >+ dest.pixels = zoomImage->data; >+ dest.BytesPerPixel = visbpp / 8; >+ ZoomSurfaceSrcCoords(x, y, width, height, &dx, &dy, &dw, &dh, &src, &dest); >+ } >+ else { >+ dx = x; dy = y; >+ dw = width; dh = height; >+ } >+ DrawScreenRegion(dx, dy, dw, dh); >+} >+ >+void SyncScreenRegionX11Thread(int x, int y, int width, int height) { >+ int dx, dy, dw, dh; >+ >+ if (zoomActive) { >+ Surface src, dest; >+ src.w = si.framebufferWidth; >+ src.h = si.framebufferHeight; >+ src.pitch = image->bytes_per_line; >+ src.pixels = image->data; >+ src.BytesPerPixel = visbpp / 8; >+ dest.w = zoomWidth; >+ dest.h = zoomHeight; >+ dest.pitch = zoomImage->bytes_per_line; >+ dest.pixels = zoomImage->data; >+ dest.BytesPerPixel = visbpp / 8; >+ ZoomSurfaceSrcCoords(x, y, width, height, &dx, &dy, &dw, &dh, &src, &dest); >+ } >+ else { >+ dx = x; dy = y; >+ dw = width; dh = height; >+ } >+ DrawAnyScreenRegionX11Thread(dx, dy, dw, dh); >+} >+ >+/* >+ * ToplevelInitBeforeRealization sets the title, geometry and other resources >+ * on the toplevel window. >+ */ >+ >+void >+ToplevelInit() >+{ >+ dpyWidth = WidthOfScreen(DefaultScreenOfDisplay(dpy)); >+ dpyHeight = HeightOfScreen(DefaultScreenOfDisplay(dpy)); >+} >+ >+/* >+ * Cleanup - perform shm cleanup operations prior to exiting. >+ */ >+ >+void >+Cleanup() >+{ >+ if (useShm || useZoomShm) >+ ShmCleanup(); >+} >+ >+void >+ShmCleanup() >+{ >+ fprintf(stderr,"ShmCleanup called\n"); >+ if (needShmCleanup) { >+ shmdt(shminfo.shmaddr); >+ shmctl(shminfo.shmid, IPC_RMID, 0); >+ needShmCleanup = False; >+ } >+ if (needZoomShmCleanup) { >+ shmdt(zoomshminfo.shmaddr); >+ shmctl(zoomshminfo.shmid, IPC_RMID, 0); >+ needZoomShmCleanup = False; >+ } >+} >+ >+static int >+ShmCreationXErrorHandler(Display *d, XErrorEvent *e) >+{ >+ caughtShmError = True; >+ return 0; >+} >+ >+XImage * >+CreateShmImage() >+{ >+ XImage *_image; >+ XErrorHandler oldXErrorHandler; >+ >+ if (!XShmQueryExtension(dpy)) >+ return NULL; >+ >+ _image = XShmCreateImage(dpy, vis, visdepth, ZPixmap, NULL, &shminfo, >+ si.framebufferWidth, si.framebufferHeight); >+ if (!_image) return NULL; >+ >+ shminfo.shmid = shmget(IPC_PRIVATE, >+ _image->bytes_per_line * _image->height, >+ IPC_CREAT|0777); >+ >+ if (shminfo.shmid == -1) { >+ XDestroyImage(_image); >+ return NULL; >+ } >+ >+ shminfo.shmaddr = _image->data = shmat(shminfo.shmid, 0, 0); >+ >+ if (shminfo.shmaddr == (char *)-1) { >+ XDestroyImage(_image); >+ shmctl(shminfo.shmid, IPC_RMID, 0); >+ return NULL; >+ } >+ >+ shminfo.readOnly = True; >+ >+ oldXErrorHandler = XSetErrorHandler(ShmCreationXErrorHandler); >+ XShmAttach(dpy, &shminfo); >+ XSync(dpy, False); >+ XSetErrorHandler(oldXErrorHandler); >+ >+ if (caughtShmError) { >+ XDestroyImage(_image); >+ shmdt(shminfo.shmaddr); >+ shmctl(shminfo.shmid, IPC_RMID, 0); >+ return NULL; >+ } >+ >+ needShmCleanup = True; >+ >+ fprintf(stderr,"Using shared memory PutImage\n"); >+ >+ return _image; >+} >+ >+void undrawCursor() { >+ int x, y, w, h; >+ >+ if ((imageIndex < 0) || !savedArea) >+ return; >+ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &x, &y, &w, &h); >+ >+ if ((w < 1) || (h < 1)) >+ return; >+ >+ CopyDataToScreenRaw(savedArea, x, y, w, h); >+ discardCursorSavedArea(); >+} >+ >+static void drawCursorImage() { >+ int x, y, w, h, pw, pixelsLeft, processingMask; >+ int skipLeft, skipRight; >+ PointerImage *pi = &pointerImages[imageIndex]; >+ CARD8 *img = (CARD8*) pi->image; >+ CARD8 *imgEnd = &img[pi->len]; >+ CARD8 *fb; >+ >+ /* check whether the source image has ended (image broken) */ >+#define CHECK_IMG(x) if (&img[x] > imgEnd) goto imgError >+ >+/* check whether the end of the framebuffer has been reached (last line) */ >+#define CHECK_END() if ((wl == 0) && (h == 1)) return >+ >+/* skip x pixels in the source (x must be < pixelsLeft!) */ >+#define SKIP_IMG(x) if ((x > 0) && !processingMask) { \ >+ CHECK_END(); \ >+ img += pw * x; \ >+ CHECK_IMG(0); \ >+ } >+ >+/* skip x pixels in source and destination */ >+#define SKIP_PIXELS(x) { int wl = x; \ >+ while (pixelsLeft <= wl) { \ >+ wl -= pixelsLeft; \ >+ SKIP_IMG(pixelsLeft); \ >+ CHECK_END(); \ >+ pixelsLeft = *(img++); \ >+ CHECK_IMG(0); \ >+ processingMask = processingMask ? 0 : 1; \ >+ } \ >+ pixelsLeft -= wl; \ >+ SKIP_IMG(wl); \ >+ } >+ >+ if (!img) >+ return; >+ >+ x = cursorX - pi->hotX; >+ y = cursorY - pi->hotY; >+ w = pi->w; >+ h = pi->h; >+ >+ if (!rectsIntersect(x, y, w, h, >+ 0, 0, si.framebufferWidth, si.framebufferHeight)) { >+ fprintf(stderr, "intersect abort\n"); >+ return; >+ } >+ >+ pw = myFormat.bitsPerPixel / 8; >+ processingMask = 1; >+ pixelsLeft = *(img++); >+ >+/* at this point everything is initialized for the macros */ >+ >+ /* skip/clip bottom lines */ >+ if ((y+h) > si.framebufferHeight) >+ h = si.framebufferHeight - y; >+ >+ /* Skip invisible top lines */ >+ while (y < 0) { >+ SKIP_PIXELS(w); >+ y++; >+ h--; >+ } >+ >+ /* calculate left/right clipping */ >+ if (x < 0) { >+ skipLeft = -x; >+ w += x; >+ x = 0; >+ } >+ else >+ skipLeft = 0; >+ >+ if ((x+w) > si.framebufferWidth) { >+ skipRight = (x+w) - si.framebufferWidth; >+ w = si.framebufferWidth - x; >+ } >+ else >+ skipRight = 0; >+ >+ fb = (CARD8*) image->data + y * image->bytes_per_line + x * visbpp / 8; >+ >+ /* Paint the thing */ >+ while (h > 0) { >+ SKIP_PIXELS(skipLeft); >+ >+ { >+ CARD8 *fbx = fb; >+ int wl = w; >+ while (pixelsLeft <= wl) { >+ wl -= pixelsLeft; >+ if ((pixelsLeft > 0) && !processingMask) { >+ int pl = pw * pixelsLeft; >+ CHECK_IMG(pl); >+ if (!appData.useBGR233) >+ memcpy(fbx, img, pl); >+ else >+ bgr233cpy(fbx, img, pixelsLeft); >+ img += pl; >+ } >+ >+ CHECK_END(); >+ fbx += pixelsLeft * visbpp / 8; >+ pixelsLeft = *(img++); >+ >+ CHECK_IMG(0); >+ processingMask = processingMask ? 0 : 1; >+ } >+ pixelsLeft -= wl; >+ if ((wl > 0) && !processingMask) { >+ int pl = pw * wl; >+ CHECK_IMG(pl); >+ if (!appData.useBGR233) >+ memcpy(fbx, img, pl); >+ else >+ bgr233cpy(fbx, img, wl); >+ img += pl; >+ } >+ } >+ >+ SKIP_PIXELS(skipRight); >+ fb += image->bytes_per_line; >+ h--; >+ } >+ return; >+ >+imgError: >+ fprintf(stderr, "Error in softcursor image %d\n", imageIndex); >+ pointerImages[imageIndex].set = 0; >+} >+ >+static void discardCursorSavedArea() { >+ if (savedArea) >+ free(savedArea); >+ savedArea = 0; >+} >+ >+static void saveCursorSavedArea() { >+ int x, y, w, h; >+ >+ if (imageIndex < 0) >+ return; >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &x, &y, &w, &h); >+ if ((w < 1) || (h < 1)) >+ return; >+ discardCursorSavedArea(); >+ savedArea = malloc(h*image->bytes_per_line); >+ if (!savedArea) { >+ fprintf(stderr,"malloc failed, saving cursor not possible\n"); >+ exit(1); >+ } >+ CopyDataFromScreen(savedArea, x, y, w, h); >+} >+ >+void drawCursor() { >+ saveCursorSavedArea(); >+ drawCursorImage(); >+} >+ >+void getBoundingRectCursor(int cx, int cy, int _imageIndex, >+ int *x, int *y, int *w, int *h) { >+ int nx, ny, nw, nh; >+ >+ if ((_imageIndex < 0) || !pointerImages[_imageIndex].set) { >+ *x = 0; >+ *y = 0; >+ *w = 0; >+ *h = 0; >+ return; >+ } >+ >+ nx = cx - pointerImages[_imageIndex].hotX; >+ ny = cy - pointerImages[_imageIndex].hotY; >+ nw = pointerImages[_imageIndex].w; >+ nh = pointerImages[_imageIndex].h; >+ if (nx < 0) { >+ nw += nx; >+ nx = 0; >+ } >+ if (ny < 0) { >+ nh += ny; >+ ny = 0; >+ } >+ if ((nx+nw) > si.framebufferWidth) >+ nw = si.framebufferWidth - nx; >+ if ((ny+nh) > si.framebufferHeight) >+ nh = si.framebufferHeight - ny; >+ if ((nw <= 0) || (nh <= 0)) { >+ *x = 0; >+ *y = 0; >+ *w = 0; >+ *h = 0; >+ return; >+ } >+ >+ *x = nx; >+ *y = ny; >+ *w = nw; >+ *h = nh; >+} >+ >+static SoftCursorState getSoftCursorState(int x, int y, int w, int h) { >+ int cx, cy, cw, ch; >+ >+ if (imageIndex < 0) >+ return SOFTCURSOR_UNAFFECTED; >+ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &cx, &cy, &cw, &ch); >+ >+ if ((cw == 0) || (ch == 0)) >+ return SOFTCURSOR_UNAFFECTED; >+ >+ if (!rectsIntersect(x, y, w, h, cx, cy, cw, ch)) >+ return SOFTCURSOR_UNAFFECTED; >+ if (rectContains(x, y, w, h, cx, cy, cw, ch)) >+ return SOFTCURSOR_UNDER; >+ else >+ return SOFTCURSOR_PART_UNDER; >+} >+ >+int rectsIntersect(int x, int y, int w, int h, >+ int x2, int y2, int w2, int h2) { >+ if (x2 >= (x+w)) >+ return 0; >+ if (y2 >= (y+h)) >+ return 0; >+ if ((x2+w2) <= x) >+ return 0; >+ if ((y2+h2) <= y) >+ return 0; >+ return 1; >+} >+ >+int rectContains(int outX, int outY, int outW, int outH, >+ int inX, int inY, int inW, int inH) { >+ if (inX < outX) >+ return 0; >+ if (inY < outY) >+ return 0; >+ if ((inX+inW) > (outX+outW)) >+ return 0; >+ if ((inY+inH) > (outY+outH)) >+ return 0; >+ return 1; >+} >+ >+void rectsJoin(int *nx1, int *ny1, int *nw1, int *nh1, >+ int x2, int y2, int w2, int h2) { >+ int ox, oy, ow, oh; >+ ox = *nx1; >+ oy = *ny1; >+ ow = *nw1; >+ oh = *nh1; >+ >+ if (x2 < ox) { >+ ow += ox - x2; >+ ox = x2; >+ } >+ if (y2 < oy) { >+ oh += oy - y2; >+ oy = y2; >+ } >+ if ((x2+w2) > (ox+ow)) >+ ow = (x2+w2) - ox; >+ if ((y2+h2) > (oy+oh)) >+ oh = (y2+h2) - oy; >+ >+ *nx1 = ox; >+ *ny1 = oy; >+ *nw1 = ow; >+ *nh1 = oh; >+} >+ >+XImage * >+CreateShmZoomImage() >+{ >+ XImage *_image; >+ XErrorHandler oldXErrorHandler; >+ >+ if (!XShmQueryExtension(dpy)) >+ return NULL; >+ >+ _image = XShmCreateImage(dpy, vis, visdepth, ZPixmap, NULL, &zoomshminfo, >+ si.framebufferWidth, si.framebufferHeight); >+ if (!_image) return NULL; >+ >+ zoomshminfo.shmid = shmget(IPC_PRIVATE, >+ _image->bytes_per_line * _image->height, >+ IPC_CREAT|0777); >+ >+ if (zoomshminfo.shmid == -1) { >+ XDestroyImage(_image); >+ return NULL; >+ } >+ >+ zoomshminfo.shmaddr = _image->data = shmat(zoomshminfo.shmid, 0, 0); >+ >+ if (zoomshminfo.shmaddr == (char *)-1) { >+ XDestroyImage(_image); >+ shmctl(zoomshminfo.shmid, IPC_RMID, 0); >+ return NULL; >+ } >+ >+ zoomshminfo.readOnly = True; >+ >+ oldXErrorHandler = XSetErrorHandler(ShmCreationXErrorHandler); >+ XShmAttach(dpy, &zoomshminfo); >+ XSync(dpy, False); >+ XSetErrorHandler(oldXErrorHandler); >+ >+ if (caughtZoomShmError) { >+ XDestroyImage(_image); >+ shmdt(zoomshminfo.shmaddr); >+ shmctl(zoomshminfo.shmid, IPC_RMID, 0); >+ return NULL; >+ } >+ >+ needZoomShmCleanup = True; >+ >+ fprintf(stderr,"Using shared memory PutImage\n"); >+ >+ return _image; >+} >+ >+ >+/* >+ * DrawZoomedScreenRegionX11Thread >+ * Never call from any other desktop.c function, only for X11 thread >+ */ >+ >+void >+DrawZoomedScreenRegionX11Thread(Window win, int zwidth, int zheight, >+ int x, int y, int width, int height) { >+ if (!image) >+ return; >+ >+ if (zwidth > si.framebufferWidth) >+ zwidth = si.framebufferWidth; >+ if (zheight > si.framebufferHeight) >+ zheight = si.framebufferHeight; >+ >+ if (!zoomActive) { >+ ZoomInit(); >+ zoomActive = True; >+ } >+ >+ if ((zoomWidth != zwidth) || (zoomHeight != zheight)) { >+ Surface src, dest; >+ >+ zoomWidth = zwidth; >+ zoomHeight = zheight; >+ >+ src.w = si.framebufferWidth; >+ src.h = si.framebufferHeight; >+ src.pitch = image->bytes_per_line; >+ src.pixels = image->data; >+ src.BytesPerPixel = visbpp / 8; >+ dest.w = zwidth; >+ dest.h = zheight; >+ dest.pitch = zoomImage->bytes_per_line; >+ dest.pixels = zoomImage->data; >+ dest.BytesPerPixel = visbpp / 8; >+ sge_transform(&src, &dest, >+ (float)dest.w/(float)src.w, (float)dest.h/(float)src.h, >+ 0, 0); >+ >+ if (useZoomShm) >+ XShmPutImage(dpy, win, gc, zoomImage, 0, 0, 0, 0, zwidth, zheight, False); >+ else >+ XPutImage(dpy, win, gc, zoomImage, 0, 0, 0, 0, zwidth, zheight); >+ return; >+ } >+ >+ if (useZoomShm) >+ XShmPutImage(dpy, win, gc, zoomImage, x, y, x, y, width, height, False); >+ else >+ XPutImage(dpy, win, gc, zoomImage, x, y, x, y, width, height); >+} >+ >+ >+static void >+ZoomInit() >+{ >+ if (zoomImage) >+ return; >+ >+ zoomImage = CreateShmZoomImage(); >+ >+ if (!zoomImage) { >+ useZoomShm = False; >+ zoomImage = XCreateImage(dpy, vis, visdepth, ZPixmap, 0, NULL, >+ si.framebufferWidth, si.framebufferHeight, >+ BitmapPad(dpy), 0); >+ >+ zoomImage->data = calloc(zoomImage->bytes_per_line * zoomImage->height, 1); >+ if (!zoomImage->data) { >+ fprintf(stderr,"malloc failed\n"); >+ exit(1); >+ } >+ } >+} >+ >+static void transformZoomSrc(int six, int siy, int siw, int sih, >+ int *dix, int *diy, int *diw, int *dih, >+ int srcW, int dstW, int srcH, int dstH) { >+ double sx, sy, sw, sh; >+ double dx, dy, dw, dh; >+ double wq, hq; >+ >+ sx = six; sy = siy; >+ sw = siw; sh = sih; >+ >+ wq = ((double)dstW) / (double) srcW; >+ hq = ((double)dstH) / (double) srcH; >+ >+ dx = sx * wq; >+ dy = sy * hq; >+ dw = sw * wq; >+ dh = sh * hq; >+ >+ *dix = dx; >+ *diy = dy; >+ *diw = dw+(dx-(int)dx)+0.5; >+ *dih = dh+(dy-(int)dy)+0.5; >+} >+ >+static void transformZoomDst(int *six, int *siy, int *siw, int *sih, >+ int dix, int diy, int diw, int dih, >+ int srcW, int dstW, int srcH, int dstH) { >+ double sx, sy, sw, sh; >+ double dx, dy, dw, dh; >+ double wq, hq; >+ >+ dx = dix; dy = diy; >+ dw = diw; dh = dih; >+ >+ wq = ((double)dstW) / (double) srcW; >+ hq = ((double)dstH) / (double) srcH; >+ >+ sx = dx / wq; >+ sy = dy / hq; >+ sw = dw / wq; >+ sh = dh / hq; >+ >+ *six = sx; >+ *siy = sy; >+ *siw = sw+(sx-(int)sx)+0.5; >+ *sih = sh+(sy-(int)sy)+0.5; >+} >+ >+ >+static void ZoomSurfaceSrcCoords(int six, int siy, int siw, int sih, >+ int *dix, int *diy, int *diw, int *dih, >+ Surface * src, Surface * dst) >+{ >+ int dx, dy, dw, dh; >+ int sx, sy, sw, sh; >+ >+ transformZoomSrc(six, siy, siw, sih, >+ &dx, &dy, &dw, &dh, >+ src->w, dst->w, src->h, dst->h); >+ dx-=2; >+ dy-=2; >+ dw+=4; >+ dh+=4; >+ >+ if (dx < 0) >+ dx = 0; >+ if (dy < 0) >+ dy = 0; >+ if (dx+dw > dst->w) >+ dw = dst->w - dx; >+ if (dy+dh > dst->h) >+ dh = dst->h - dy; >+ >+ transformZoomDst(&sx, &sy, &sw, &sh, >+ dx, dy, dw, dh, >+ src->w, dst->w, src->h, dst->h); >+ >+ if (sx+sw > src->w) >+ sw = src->w - sx; >+ if (sy+sh > src->h) >+ sh = src->h - sy; >+ >+ ZoomSurfaceCoords32(sx, sy, sw, sh, dx, dy, src, dst); >+ >+ *dix = dx; >+ *diy = dy; >+ *diw = dw; >+ *dih = dh; >+} >+ >+static void ZoomSurfaceCoords32(int sx, int sy, int sw, int sh, >+ int dx, int dy, >+ Surface * src, Surface * dst) >+{ >+ Surface s2; >+ >+ s2 = *src; >+ s2.pixels = ((char*)s2.pixels) + (sx * s2.BytesPerPixel) + (sy * src->pitch); >+ s2.w = sw; >+ s2.h = sh; >+ sge_transform(&s2, dst, >+ (float)dst->w/(float)src->w, (float)dst->h/(float)src->h, >+ dx, dy); >+} >+ >+ >+#define sge_clip_xmin(pnt) 0 >+#define sge_clip_xmax(pnt) pnt->w >+#define sge_clip_ymin(pnt) 0 >+#define sge_clip_ymax(pnt) pnt->h >+ >+/*================================================================================== >+// Helper function to sge_transform() >+// Returns the bounding box >+//================================================================================== >+*/ >+static void _calcRect(Surface *src, Surface *dst, float xscale, float yscale, >+ Uint16 qx, Uint16 qy, >+ Sint16 *xmin, Sint16 *ymin, Sint16 *xmax, Sint16 *ymax) >+{ >+ Sint16 x, y, rx, ry; >+ int i; >+ >+ /* Clip to src surface */ >+ Sint16 sxmin = sge_clip_xmin(src); >+ Sint16 sxmax = sge_clip_xmax(src); >+ Sint16 symin = sge_clip_ymin(src); >+ Sint16 symax = sge_clip_ymax(src); >+ Sint16 sx[5]; >+ Sint16 sy[4]; >+ >+ /* We don't really need fixed-point here >+ * but why not? */ >+ Sint32 ictx = (Sint32) (xscale * 8192.0); >+ Sint32 icty = (Sint32) (yscale * 8192.0); >+ >+ sx[0] = sxmin; >+ sx[1] = sxmax; >+ sx[2] = sxmin; >+ sx[3] = sxmax; >+ sy[0] = symin; >+ sy[1] = symax; >+ sy[2] = symax; >+ sy[3] = symin; >+ >+ /* Calculate the four corner points */ >+ for(i=0; i<4; i++){ >+ rx = sx[i]; >+ ry = sy[i]; >+ >+ x = (Sint16)(((ictx*rx) >> 13) + qx); >+ y = (Sint16)(((icty*ry) >> 13) + qy); >+ >+ >+ if(i==0){ >+ *xmax = *xmin = x; >+ *ymax = *ymin = y; >+ }else{ >+ if(x>*xmax) >+ *xmax=x; >+ else if(x<*xmin) >+ *xmin=x; >+ >+ if(y>*ymax) >+ *ymax=y; >+ else if(y<*ymin) >+ *ymin=y; >+ } >+ } >+ >+ /* Better safe than sorry...*/ >+ *xmin -= 1; >+ *ymin -= 1; >+ *xmax += 1; >+ *ymax += 1; >+ >+ /* Clip to dst surface */ >+ if( !dst ) >+ return; >+ if( *xmin < sge_clip_xmin(dst) ) >+ *xmin = sge_clip_xmin(dst); >+ if( *xmax > sge_clip_xmax(dst) ) >+ *xmax = sge_clip_xmax(dst); >+ if( *ymin < sge_clip_ymin(dst) ) >+ *ymin = sge_clip_ymin(dst); >+ if( *ymax > sge_clip_ymax(dst) ) >+ *ymax = sge_clip_ymax(dst); >+} >+ >+ >+/*================================================================================== >+** Scale by scale and place at position (qx,qy). >+** >+** >+** Developed with the help from Terry Hancock (hancock@earthlink.net) >+** >+**==================================================================================*/ >+/* First we need some macros to handle different bpp >+ * I'm sorry about this... >+ */ >+#define TRANSFORM(UintXX, DIV) \ >+ Sint32 src_pitch=src->pitch/DIV; \ >+ Sint32 dst_pitch=dst->pitch/DIV; \ >+ UintXX *src_row = (UintXX *)src->pixels; \ >+ UintXX *dst_row; \ >+\ >+ for (y=ymin; y<ymax; y++){ \ >+ dy = y - qy; \ >+\ >+ sx = (Sint32)ctdx; /* Compute source anchor points */ \ >+ sy = (Sint32)(cty*dy); \ >+\ >+ /* Calculate pointer to dst surface */ \ >+ dst_row = (UintXX *)dst->pixels + y*dst_pitch; \ >+\ >+ for (x=xmin; x<xmax; x++){ \ >+ rx=(Sint16)(sx >> 13); /* Convert from fixed-point */ \ >+ ry=(Sint16)(sy >> 13); \ >+\ >+ /* Make sure the source pixel is actually in the source image. */ \ >+ if( (rx>=sxmin) && (rx<sxmax) && (ry>=symin) && (ry<symax) ) \ >+ *(dst_row + x) = *(src_row + ry*src_pitch + rx); \ >+\ >+ sx += ctx; /* Incremental transformations */ \ >+ } \ >+ } >+ >+ >+/* Interpolated transform */ >+#define TRANSFORM_AA(UintXX, DIV) \ >+ Sint32 src_pitch=src->pitch/DIV; \ >+ Sint32 dst_pitch=dst->pitch/DIV; \ >+ UintXX *src_row = (UintXX *)src->pixels; \ >+ UintXX *dst_row; \ >+ UintXX c1, c2, c3, c4;\ >+ Uint32 R, G, B, A=0; \ >+ UintXX Rmask = image->red_mask;\ >+ UintXX Gmask = image->green_mask;\ >+ UintXX Bmask = image->blue_mask;\ >+ UintXX Amask = 0;\ >+ Uint32 wx, wy;\ >+ Uint32 p1, p2, p3, p4;\ >+\ >+ /* >+ * Interpolation: >+ * We calculate the distances from our point to the four nearest pixels, d1..d4. >+ * d(a,b) = sqrt(a�+b�) ~= 0.707(a+b) (Pythagoras (Taylor) expanded around (0.5;0.5)) >+ * >+ * 1 wx 2 >+ * *-|-* (+ = our point at (x,y)) >+ * | | | (* = the four nearest pixels) >+ * wy --+ | wx = float(x) - int(x) >+ * | | wy = float(y) - int(y) >+ * *---* >+ * 3 4 >+ * d1 = d(wx,wy) d2 = d(1-wx,wy) d3 = d(wx,1-wy) d4 = d(1-wx,1-wy) >+ * We now want to weight each pixels importance - it's vicinity to our point: >+ * w1=d4 w2=d3 w3=d2 w4=d1 (Yes it works... just think a bit about it) >+ * >+ * If the pixels have the colors c1..c4 then our point should have the color >+ * c = (w1*c1 + w2*c2 + w3*c3 + w4*c4)/(w1+w2+w3+w4) (the weighted average) >+ * but w1+w2+w3+w4 = 4*0.707 so we might as well write it as >+ * c = p1*c1 + p2*c2 + p3*c3 + p4*c4 where p1..p4 = (w1..w4)/(4*0.707) >+ * >+ * But p1..p4 are fixed point so we can just divide the fixed point constant! >+ * 8192/(4*0.71) = 2897 and we can skip 0.71 too (the division will cancel it everywhere) >+ * 8192/4 = 2048 >+ * >+ * 020102: I changed the fixed-point representation for the variables in the weighted average >+ * to 24.7 to avoid problems with 32bit colors. Everything else is still 18.13. This >+ * does however not solve the problem with 32bit RGBA colors... >+ */\ >+\ >+ Sint32 one = 2048>>6; /* 1 in Fixed-point */ \ >+ Sint32 two = 2*2048>>6; /* 2 in Fixed-point */ \ >+\ >+ for (y=ymin; y<ymax; y++){ \ >+ dy = y - qy; \ >+\ >+ sx = (Sint32)(ctdx); /* Compute source anchor points */ \ >+ sy = (Sint32)(cty*dy); \ >+\ >+ /* Calculate pointer to dst surface */ \ >+ dst_row = (UintXX *)dst->pixels + y*dst_pitch; \ >+\ >+ for (x=xmin; x<xmax; x++){ \ >+ rx=(Sint16)(sx >> 13); /* Convert from fixed-point */ \ >+ ry=(Sint16)(sy >> 13); \ >+\ >+ /* Make sure the source pixel is actually in the source image. */ \ >+ if( (rx>=sxmin) && (rx+1<sxmax) && (ry>=symin) && (ry+1<symax) ){ \ >+ wx = (sx & 0x00001FFF) >>8; /* (float(x) - int(x)) / 4 */ \ >+ wy = (sy & 0x00001FFF) >>8;\ >+\ >+ p4 = wx+wy;\ >+ p3 = one-wx+wy;\ >+ p2 = wx+one-wy;\ >+ p1 = two-wx-wy;\ >+\ >+ c1 = *(src_row + ry*src_pitch + rx);\ >+ c2 = *(src_row + ry*src_pitch + rx+1);\ >+ c3 = *(src_row + (ry+1)*src_pitch + rx);\ >+ c4 = *(src_row + (ry+1)*src_pitch + rx+1);\ >+\ >+ /* Calculate the average */\ >+ R = ((p1*(c1 & Rmask) + p2*(c2 & Rmask) + p3*(c3 & Rmask) + p4*(c4 & Rmask))>>7) & Rmask;\ >+ G = ((p1*(c1 & Gmask) + p2*(c2 & Gmask) + p3*(c3 & Gmask) + p4*(c4 & Gmask))>>7) & Gmask;\ >+ B = ((p1*(c1 & Bmask) + p2*(c2 & Bmask) + p3*(c3 & Bmask) + p4*(c4 & Bmask))>>7) & Bmask;\ >+ if(Amask)\ >+ A = ((p1*(c1 & Amask) + p2*(c2 & Amask) + p3*(c3 & Amask) + p4*(c4 & Amask))>>7) & Amask;\ >+ \ >+ *(dst_row + x) = R | G | B | A;\ >+ } \ >+ sx += ctx; /* Incremental transformations */ \ >+ } \ >+ } >+ >+void sge_transform(Surface *src, Surface *dst, float xscale, float yscale, Uint16 qx, Uint16 qy) >+{ >+ Sint32 dy, sx, sy; >+ Sint16 x, y, rx, ry; >+ Rect r; >+ >+ Sint32 ctx, cty; >+ Sint16 xmin, xmax, ymin, ymax; >+ Sint16 sxmin, sxmax, symin, symax; >+ Sint32 dx, ctdx; >+ >+ >+ /* Here we use 18.13 fixed point integer math >+ // Sint32 should have 31 usable bits and one for sign >+ // 2^13 = 8192 >+ */ >+ >+ /* Check scales */ >+ Sint32 maxint = (Sint32)(pow(2, sizeof(Sint32)*8 - 1 - 13)); /* 2^(31-13) */ >+ >+ r.x = r.y = r.w = r.h = 0; >+ >+ if( xscale == 0 || yscale == 0) >+ return; >+ >+ if( 8192.0/xscale > maxint ) >+ xscale = (float)(8192.0/maxint); >+ else if( 8192.0/xscale < -maxint ) >+ xscale = (float)(-8192.0/maxint); >+ >+ if( 8192.0/yscale > maxint ) >+ yscale = (float)(8192.0/maxint); >+ else if( 8192.0/yscale < -maxint ) >+ yscale = (float)(-8192.0/maxint); >+ >+ >+ /* Fixed-point equivalents */ >+ ctx = (Sint32)(8192.0/xscale); >+ cty = (Sint32)(8192.0/yscale); >+ >+ /* Compute a bounding rectangle */ >+ xmin=0; xmax=dst->w; ymin=0; ymax=dst->h; >+ _calcRect(src, dst, xscale, yscale, >+ qx, qy, &xmin, &ymin, &xmax, &ymax); >+ >+ /* Clip to src surface */ >+ sxmin = sge_clip_xmin(src); >+ sxmax = sge_clip_xmax(src); >+ symin = sge_clip_ymin(src); >+ symax = sge_clip_ymax(src); >+ >+ /* Some terms in the transform are constant */ >+ dx = xmin - qx; >+ ctdx = ctx*dx; >+ >+ /* Use the correct bpp */ >+ if( src->BytesPerPixel == dst->BytesPerPixel){ >+ switch( src->BytesPerPixel ){ >+ case 1: { /* Assuming 8-bpp */ >+ TRANSFORM(Uint8, 1) >+ } >+ break; >+ case 2: { /* Probably 15-bpp or 16-bpp */ >+ TRANSFORM_AA(Uint16, 2) >+ } >+ break; >+ case 4: { /* Probably 32-bpp */ >+ TRANSFORM_AA(Uint32, 4) >+ } >+ break; >+ } >+ } >+} >+ >+void freeDesktopResources() { >+ Cleanup(); >+ if (image) { >+ XDestroyImage(image); >+ } >+ if (zoomImage) { >+ XDestroyImage(zoomImage); >+ } >+ if (savedArea) >+ free(savedArea); >+ >+ if (gcInited) { >+ XFreeGC(dpy, gc); >+ XFreeGC(dpy, srcGC); >+ XFreeGC(dpy, dstGC); >+ } >+ >+ caughtShmError = False; >+ needShmCleanup = False; >+ caughtZoomShmError = False; >+ needZoomShmCleanup = False; >+ gcInited = False; >+ image = NULL; >+ useShm = True; >+ zoomActive = False; >+ zoomImage = NULL; >+ useZoomShm = True; >+ savedArea = NULL; >+} >+ >+ >+/* >+ * ColorRectangle32 >+ * Only used for debugging / visualizing output >+ */ >+/* >+static void >+ColorRectangle32(XImage *img, CARD32 fg, int x, int y, int width, int height) >+{ >+ int i, h; >+ int scrWidthInBytes = img->bytes_per_line; >+ char *scr; >+ CARD32 *scr32; >+ >+ if ((!img) || (!img->data)) >+ return; >+ >+ scr = (img->data + y * scrWidthInBytes + x * 4); >+ >+ if (!CheckRectangle(x, y, width, height)) >+ return; >+ >+ for (h = 0; h < height; h++) { >+ scr32 = (CARD32*) scr; >+ for (i = 0; i < width; i++) { >+ CARD32 n = 0; >+ CARD32 p = scr32[i]; >+ if (0xff & fg) >+ n |= ((( 0xff & p)+( 0xff & fg)) >> 2) & 0xff; >+ else >+ n |= (0xff & p); >+ if (0xff00 & fg) >+ n |= ((( 0xff00 & p)+( 0xff00 & fg)) >> 2) & 0xff00; >+ else >+ n |= (0xff00 & p); >+ if (0xff0000 & fg) >+ n |= (((0xff0000 & p)+(0xff0000 & fg)) >> 2) & 0xff0000; >+ else >+ n |= (0xff0000 & p); >+ scr32[i] = n; >+ } >+ scr += scrWidthInBytes; >+ } >+} >+*/ >+ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/hextile.c tdenetwork-trinity-14.1.0/krdc/vnc/hextile.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/hextile.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/hextile.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,129 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * hextile.c - handle hextile encoding. >+ * >+ * This file shouldn't be compiled directly. It is included multiple times by >+ * rfbproto.c, each time with a different definition of the macro BPP. For >+ * each value of BPP, this file defines a function which handles a hextile >+ * encoded rectangle with BPP bits per pixel. >+ */ >+ >+#define HandleHextileBPP CONCAT2E(HandleHextile,BPP) >+#define CARDBPP CONCAT2E(CARD,BPP) >+#define GET_PIXEL CONCAT2E(GET_PIXEL,BPP) >+#define FillRectangleBPP CONCAT2E(FillRectangle,BPP) >+ >+static Bool >+HandleHextileBPP (int rx, int ry, int rw, int rh) >+{ >+ CARDBPP bg, fg; >+ int i; >+ CARD8 *ptr; >+ int x, y, w, h; >+ int sx, sy, sw, sh; >+ CARD8 subencoding; >+ CARD8 nSubrects; >+ >+ for (y = ry; y < ry+rh; y += 16) { >+ for (x = rx; x < rx+rw; x += 16) { >+ w = h = 16; >+ if (rx+rw - x < 16) >+ w = rx+rw - x; >+ if (ry+rh - y < 16) >+ h = ry+rh - y; >+ >+ if (!ReadFromRFBServer((char *)&subencoding, 1)) >+ return False; >+ >+ if (subencoding & rfbHextileRaw) { >+ if (!ReadFromRFBServer(buffer, w * h * (BPP / 8))) >+ return False; >+ >+ CopyDataToScreen(buffer, x, y, w, h); >+ continue; >+ } >+ >+ if (subencoding & rfbHextileBackgroundSpecified) >+ if (!ReadFromRFBServer((char *)&bg, sizeof(bg))) >+ return False; >+ >+ LockFramebuffer(); >+ FillRectangleBPP(bg, x, y, w, h); >+ >+ if (subencoding & rfbHextileForegroundSpecified) >+ if (!ReadFromRFBServer((char *)&fg, sizeof(fg))) { >+ UnlockFramebuffer(); >+ return False; >+ } >+ >+ if (!(subencoding & rfbHextileAnySubrects)) { >+ UnlockFramebuffer(); >+ SyncScreenRegion(x, y, w, h); >+ continue; >+ } >+ >+ if (!ReadFromRFBServer((char *)&nSubrects, 1)) { >+ UnlockFramebuffer(); >+ return False; >+ } >+ >+ ptr = (CARD8 *)buffer; >+ >+ if (subencoding & rfbHextileSubrectsColoured) { >+ if (!ReadFromRFBServer(buffer, nSubrects * (2 + (BPP / 8)))) { >+ UnlockFramebuffer(); >+ return False; >+ } >+ >+ for (i = 0; i < nSubrects; i++) { >+ GET_PIXEL(fg, ptr); >+ sx = rfbHextileExtractX(*ptr); >+ sy = rfbHextileExtractY(*ptr); >+ ptr++; >+ sw = rfbHextileExtractW(*ptr); >+ sh = rfbHextileExtractH(*ptr); >+ ptr++; >+ FillRectangleBPP(fg, x+sx, y+sy, sw, sh); >+ } >+ >+ } else { >+ if (!ReadFromRFBServer(buffer, nSubrects * 2)) { >+ UnlockFramebuffer(); >+ return False; >+ } >+ >+ for (i = 0; i < nSubrects; i++) { >+ sx = rfbHextileExtractX(*ptr); >+ sy = rfbHextileExtractY(*ptr); >+ ptr++; >+ sw = rfbHextileExtractW(*ptr); >+ sh = rfbHextileExtractH(*ptr); >+ ptr++; >+ FillRectangleBPP(fg, x+sx, y+sy, sw, sh); >+ } >+ } >+ UnlockFramebuffer(); >+ SyncScreenRegion(x, y, w, h); >+ } >+ } >+ >+ return True; >+} >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.cpp tdenetwork-trinity-14.1.0/krdc/vnc/kvncview.cpp >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.cpp 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/kvncview.cpp 2023-05-26 21:29:57.665214836 +0300 >@@ -2,8 +2,7 @@ > kvncview.cpp - main widget > ------------------- > begin : Thu Dec 20 15:11:42 CET 2001 >- copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net> >- (C) 2001-2003 by Tim Jansen >+ copyright : (C) 2001-2003 by Tim Jansen > email : tim@tjansen.de > ***************************************************************************/ > >@@ -35,8 +34,6 @@ > #include <tqbitmap.h> > #include <tqmutex.h> > #include <tqvbox.h> >-#include <tqtimer.h> >-#include <tqpainter.h> > #include <tqwaitcondition.h> > > #include "vncviewer.h" >@@ -50,6 +47,7 @@ > * application resource specs. The AppData structure is defined in the header > * file. > */ >+AppData appData; > bool appDataConfigured = false; > > Display* dpy; >@@ -75,7 +73,8 @@ > DotCursorState dotCursorState, > const TQString &encodings) : > KRemoteView(parent, name, TQt::WResizeNoErase | TQt::WRepaintNoErase | TQt::WStaticContents), >- m_cthreadObject(this, m_quitFlag), >+ m_cthread(this, m_wthread, m_quitFlag), >+ m_wthread(this, m_quitFlag), > m_quitFlag(false), > m_enableFramebufferLocking(false), > m_scaling(false), >@@ -148,6 +147,8 @@ > > void KVncView::startQuitting() { > m_quitFlag = true; >+ m_wthread.kick(); >+ m_cthread.kick(); > } > > bool KVncView::isQuitting() { >@@ -156,37 +157,44 @@ > > void KVncView::configureApp(Quality q, const TQString specialEncodings) { > appDataConfigured = true; >- m_cthreadObject.cl->appData.shareDesktop = 1; >- m_cthreadObject.cl->appData.viewOnly = 0; >+ appData.shareDesktop = 1; >+ appData.viewOnly = 0; > > if (q == QUALITY_LOW) { >- m_cthreadObject.cl->appData.useBGR233 = 1; >- m_cthreadObject.cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw"; >- m_cthreadObject.cl->appData.compressLevel = 9; >- m_cthreadObject.cl->appData.qualityLevel = 1; >- m_cthreadObject.cl->appData.useRemoteCursor = 1; >+ appData.useBGR233 = 1; >+ appData.encodingsString = "background copyrect softcursor tight zlib hextile raw"; >+ appData.compressLevel = -1; >+ appData.qualityLevel = 1; >+ appData.dotCursor = 1; > } > else if (q == QUALITY_MEDIUM) { >- m_cthreadObject.cl->appData.useBGR233 = 0; >- m_cthreadObject.cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw"; >- m_cthreadObject.cl->appData.compressLevel = 5; >- m_cthreadObject.cl->appData.qualityLevel = 7; >- m_cthreadObject.cl->appData.useRemoteCursor = 1; >+ appData.useBGR233 = 0; >+ appData.encodingsString = "background copyrect softcursor tight zlib hextile raw"; >+ appData.compressLevel = -1; >+ appData.qualityLevel = 7; >+ appData.dotCursor = 1; > } > else if ((q == QUALITY_HIGH) || (q == QUALITY_UNKNOWN)) { >- m_cthreadObject.cl->appData.useBGR233 = 0; >- m_cthreadObject.cl->appData.encodingsString = "copyrect hextile raw"; >- m_cthreadObject.cl->appData.compressLevel = 0; >- m_cthreadObject.cl->appData.qualityLevel = 9; >- m_cthreadObject.cl->appData.useRemoteCursor = 1; >+ appData.useBGR233 = 0; >+ appData.encodingsString = "copyrect softcursor hextile raw"; >+ appData.compressLevel = -1; >+ appData.qualityLevel = 9; >+ appData.dotCursor = 1; > } > >- if (!specialEncodings.isNull()) { >- m_cthreadObject.cl->appData.encodingsString = specialEncodings.latin1(); >- } >+ if (!specialEncodings.isNull()) >+ appData.encodingsString = specialEncodings.latin1(); >+ >+ appData.nColours = 256; >+ appData.useSharedColours = 1; >+ appData.requestedDepth = 0; >+ >+ appData.rawDelay = 0; >+ appData.copyRectDelay = 0; > >- m_cthreadObject.cl->appData.nColours = 256; >- m_cthreadObject.cl->appData.requestedDepth = 0; >+ if (!appData.dotCursor) >+ m_cursorState = DOT_CURSOR_OFF; >+ showDotCursorInternal(); > } > > bool KVncView::checkLocalKRfb() { >@@ -289,10 +297,7 @@ > > setStatus(REMOTE_VIEW_CONNECTING); > >- m_cthreadObject.moveToThread(&m_cthread); >- TQTimer::singleShot(0, &m_cthreadObject, SLOT(run())); > m_cthread.start(); >- > setBackgroundMode(TQt::NoBackground); > return true; > } >@@ -301,6 +306,8 @@ > { > startQuitting(); > m_cthread.wait(); >+ m_wthread.wait(); >+ freeResources(); > } > > bool KVncView::supportsLocalCursor() const { >@@ -345,16 +352,9 @@ > setMaximumSize(m_framebufferSize); > setMinimumSize(m_framebufferSize.width()/16, > m_framebufferSize.height()/16); >- >- m_cthreadObject.setScaling(width(), height()); > } >- else { >+ else > setFixedSize(m_framebufferSize); >- m_cthreadObject.setScaling(-1, -1); >- } >- >- // Force full redraw >- drawRegion(0, 0, width(), height()); > } > } > >@@ -365,18 +365,12 @@ > e->rect().height()); > } > >-void KVncView::resizeEvent(TQResizeEvent *e) { >- if (m_scaling) { >- m_cthreadObject.setScaling(width(), height()); >- >- // Force full redraw >- drawRegion(0, 0, width(), height()); >- } >-} >- > void KVncView::drawRegion(int x, int y, int w, int h) { >- TQPainter painter(this); >- painter.drawImage(TQRect(x, y, w, h), m_cthreadObject.image(x, y, w, h)); >+ if (m_scaling) >+ DrawZoomedScreenRegionX11Thread(winId(), width(), height(), >+ x, y, w, h); >+ else >+ DrawScreenRegionX11Thread(winId(), x, y, w, h); > } > > void KVncView::customEvent(TQCustomEvent *e) >@@ -391,6 +385,9 @@ > setFixedSize(m_framebufferSize); > emit changeSize(sre->width(), sre->height()); > } >+ else if (e->type() == DesktopInitEventType) { >+ m_cthread.desktopInit(); >+ } > else if (e->type() == StatusChangeEventType) { > StatusChangeEvent *sce = (StatusChangeEvent*) e; > setStatus(sce->status()); >@@ -448,7 +445,7 @@ > wallet->setFolder(krdc_folder); > TQString newPass; > if ( wallet->hasEntry(kvncview->host()) && !wallet->readPassword(kvncview->host(), newPass) ) { >- password=newPass; >+ password=newPass.latin1(); > } > } > } >@@ -566,13 +563,10 @@ > x = (x * m_framebufferSize.width()) / width(); > y = (y * m_framebufferSize.height()) / height(); > } >- m_cthreadObject.queueMouseEvent(x, y, m_buttonMask); >+ m_wthread.queueMouseEvent(x, y, m_buttonMask); > >- if (m_enableClientCursor) { >- // FIXME >- // How to draw soft cursor? >- // DrawCursorX11Thread(x, y); // in rfbproto.c >- } >+ if (m_enableClientCursor) >+ DrawCursorX11Thread(x, y); // in rfbproto.c > } > > void KVncView::mousePressEvent(TQMouseEvent *e) { >@@ -613,8 +607,8 @@ > x = (x * m_framebufferSize.width()) / width(); > y = (y * m_framebufferSize.height()) / height(); > } >- m_cthreadObject.queueMouseEvent(x, y, eb|m_buttonMask); >- m_cthreadObject.queueMouseEvent(x, y, m_buttonMask); >+ m_wthread.queueMouseEvent(x, y, eb|m_buttonMask); >+ m_wthread.queueMouseEvent(x, y, m_buttonMask); > e->accept(); > } > >@@ -627,25 +621,25 @@ > KKeyNative k(xe); > uint mod = k.mod(); > if (mod & KKeyNative::modX(KKey::SHIFT)) >- m_cthreadObject.queueKeyEvent(XK_Shift_L, true); >+ m_wthread.queueKeyEvent(XK_Shift_L, true); > if (mod & KKeyNative::modX(KKey::CTRL)) >- m_cthreadObject.queueKeyEvent(XK_Control_L, true); >+ m_wthread.queueKeyEvent(XK_Control_L, true); > if (mod & KKeyNative::modX(KKey::ALT)) >- m_cthreadObject.queueKeyEvent(XK_Alt_L, true); >+ m_wthread.queueKeyEvent(XK_Alt_L, true); > if (mod & KKeyNative::modX(KKey::WIN)) >- m_cthreadObject.queueKeyEvent(XK_Meta_L, true); >+ m_wthread.queueKeyEvent(XK_Meta_L, true); > >- m_cthreadObject.queueKeyEvent(k.sym(), true); >- m_cthreadObject.queueKeyEvent(k.sym(), false); >+ m_wthread.queueKeyEvent(k.sym(), true); >+ m_wthread.queueKeyEvent(k.sym(), false); > > if (mod & KKeyNative::modX(KKey::WIN)) >- m_cthreadObject.queueKeyEvent(XK_Meta_L, false); >+ m_wthread.queueKeyEvent(XK_Meta_L, false); > if (mod & KKeyNative::modX(KKey::ALT)) >- m_cthreadObject.queueKeyEvent(XK_Alt_L, false); >+ m_wthread.queueKeyEvent(XK_Alt_L, false); > if (mod & KKeyNative::modX(KKey::CTRL)) >- m_cthreadObject.queueKeyEvent(XK_Control_L, false); >+ m_wthread.queueKeyEvent(XK_Control_L, false); > if (mod & KKeyNative::modX(KKey::SHIFT)) >- m_cthreadObject.queueKeyEvent(XK_Shift_L, false); >+ m_wthread.queueKeyEvent(XK_Shift_L, false); > > m_mods.clear(); > } >@@ -678,7 +672,7 @@ > else > unpressModifiers(); > } >- m_cthreadObject.queueKeyEvent(s, pressed); >+ m_wthread.queueKeyEvent(s, pressed); > } > return true; > } >@@ -687,7 +681,7 @@ > TQValueList<unsigned int> keys = m_mods.keys(); > TQValueList<unsigned int>::const_iterator it = keys.begin(); > while (it != keys.end()) { >- m_cthreadObject.queueKeyEvent(*it, false); >+ m_wthread.queueKeyEvent(*it, false); > it++; > } > m_mods.clear(); >@@ -725,7 +719,7 @@ > if (text.length() > MAX_SELECTION_LENGTH) > return; > >- m_cthreadObject.queueClientCut(text); >+ m_wthread.queueClientCut(text); > } > > void KVncView::selectionChanged() { >@@ -744,7 +738,7 @@ > if (text.length() > MAX_SELECTION_LENGTH) > return; > >- m_cthreadObject.queueClientCut(text); >+ m_wthread.queueClientCut(text); > } > > >@@ -776,7 +770,7 @@ > locks and signals are there to protect against deadlocks and other > horribleness. Be careful making changes here. > */ >-int getPassword(char * &passwd) { >+int getPassword(char *passwd, int pwlen) { > int retV = 0; > > //Prepare the system >@@ -803,7 +797,9 @@ > > //Process the password if we got it, clear it if we didn't > if (retV) { >- passwd = strdup(password.utf8()); >+ strncpy(passwd, password.utf8(), pwlen); >+ } else { >+ passwd[0] = 0; > } > > //Pack up and go home >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.h tdenetwork-trinity-14.1.0/krdc/vnc/kvncview.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/kvncview.h 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/kvncview.h 2022-09-18 07:50:27.000000000 +0300 >@@ -2,8 +2,7 @@ > kvncview.h - widget that shows the vnc client > ------------------- > begin : Thu Dec 20 15:11:42 CET 2001 >- copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net> >- (C) 2001-2003 by Tim Jansen >+ copyright : (C) 2001-2003 by Tim Jansen > email : tim@tjansen.de > ***************************************************************************/ > >@@ -25,6 +24,7 @@ > > #include "pointerlatencyometer.h" > #include "hostpreferences.h" >+#include "vnctypes.h" > #include "threads.h" > > class TQClipBoard; >@@ -34,8 +34,8 @@ > TQ_OBJECT > > private: >- ControllerThreadObject m_cthreadObject; >- TQEventLoopThread m_cthread; >+ ControllerThread m_cthread; >+ WriterThread m_wthread; > volatile bool m_quitFlag; // if set: all threads should die ASAP > TQMutex m_framebufferLock; > bool m_enableFramebufferLocking; >@@ -74,7 +74,6 @@ > void mouseMoveEvent(TQMouseEvent*); > void wheelEvent(TQWheelEvent *); > void focusOutEvent(TQFocusEvent *); >- void resizeEvent(TQResizeEvent *); > bool x11Event(XEvent*); > > public: >@@ -117,8 +116,6 @@ > > > private slots: >-// void requestPassword(); >- > void clipboardChanged(); > void selectionChanged(); > }; >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/rfbproto.c tdenetwork-trinity-14.1.0/krdc/vnc/rfbproto.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/rfbproto.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/rfbproto.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,1342 @@ >+/* >+ * Copyright (C) 2002, Tim Jansen. All Rights Reserved. >+ * Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved. >+ * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * rfbproto.c - functions to deal with client side of RFB protocol. >+ * tim@tjansen.de: - added softcursor encoding >+ * - changed various things for krdc >+ */ >+ >+#include <unistd.h> >+#include <errno.h> >+#include <pwd.h> >+#include "vncviewer.h" >+#include "vncauth.h" >+#include <zlib.h> >+#include <jpeglib.h> >+ >+static Bool HandleHextile8(int rx, int ry, int rw, int rh); >+static Bool HandleHextile16(int rx, int ry, int rw, int rh); >+static Bool HandleHextile32(int rx, int ry, int rw, int rh); >+static Bool HandleZlib8(int rx, int ry, int rw, int rh); >+static Bool HandleZlib16(int rx, int ry, int rw, int rh); >+static Bool HandleZlib32(int rx, int ry, int rw, int rh); >+static Bool HandleTight8(int rx, int ry, int rw, int rh); >+static Bool HandleTight16(int rx, int ry, int rw, int rh); >+static Bool HandleTight32(int rx, int ry, int rw, int rh); >+ >+static long ReadCompactLen (void); >+ >+static void JpegInitSource(j_decompress_ptr cinfo); >+static boolean JpegFillInputBuffer(j_decompress_ptr cinfo); >+static void JpegSkipInputData(j_decompress_ptr cinfo, long num_bytes); >+static void JpegTermSource(j_decompress_ptr cinfo); >+static void JpegSetSrcManager(j_decompress_ptr cinfo, CARD8 *compressedData, >+ int compressedLen); >+ >+ >+#define RGB24_TO_PIXEL(bpp,r,g,b) \ >+ ((((CARD##bpp)(r) & 0xFF) * myFormat.redMax + 127) / 255 \ >+ << myFormat.redShift | \ >+ (((CARD##bpp)(g) & 0xFF) * myFormat.greenMax + 127) / 255 \ >+ << myFormat.greenShift | \ >+ (((CARD##bpp)(b) & 0xFF) * myFormat.blueMax + 127) / 255 \ >+ << myFormat.blueShift) >+ >+int rfbsock; >+char *desktopName; >+rfbPixelFormat myFormat; >+rfbServerInitMsg si; >+ >+int endianTest = 1; >+ >+/* >+ * Softcursor variables >+ */ >+ >+int cursorX, cursorY; >+int imageIndex = -1; >+ >+PointerImage pointerImages[rfbSoftCursorMaxImages]; >+ >+ >+/* Hextile assumes it is big enough to hold 16 * 16 * 32 bits. >+ Tight encoding assumes BUFFER_SIZE is at least 16384 bytes. */ >+ >+#define BUFFER_SIZE (16384) >+static char buffer[BUFFER_SIZE]; >+ >+ >+/* The zlib encoding requires expansion/decompression/deflation of the >+ compressed data in the "buffer" above into another, result buffer. >+ However, the size of the result buffer can be determined precisely >+ based on the bitsPerPixel, height and width of the rectangle. We >+ allocate this buffer one time to be the full size of the buffer. */ >+ >+static int raw_buffer_size = -1; >+static char *raw_buffer = NULL; >+ >+static z_stream decompStream; >+static Bool decompStreamInited = False; >+ >+ >+/* >+ * Variables for the ``tight'' encoding implementation. >+ */ >+ >+/* Separate buffer for compressed data. */ >+#define ZLIB_BUFFER_SIZE 512 >+static char zlib_buffer[ZLIB_BUFFER_SIZE]; >+ >+/* Four independent compression streams for zlib library. */ >+static z_stream zlibStream[4]; >+static Bool zlibStreamActive[4] = { >+ False, False, False, False >+}; >+ >+/* Filter stuff. Should be initialized by filter initialization code. */ >+static Bool cutZeros; >+static int rectWidth, rectColors; >+static char tightPalette[256*4]; >+static CARD8 tightPrevRow[2048*3*sizeof(CARD16)]; >+ >+/* JPEG decoder state. */ >+static Bool jpegError; >+ >+/* Maximum length for the cut buffer (16 MB)*/ >+#define MAX_CUTBUFFER (1024*1024*16) >+ >+/* Maximum length for the strings (64 kB)*/ >+#define MAX_STRING (1024*64) >+ >+/* Maximum length for the strings (32 MB)*/ >+#define MAX_JPEG_SIZE (1024*1024*32) >+ >+ >+/* >+ * ConnectToRFBServer. >+ */ >+ >+int >+ConnectToRFBServer(const char *hostname, int port) >+{ >+ unsigned int host; >+ >+ if (!StringToIPAddr(hostname, &host)) { >+ fprintf(stderr,"Couldn't convert '%s' to host address\n", hostname); >+ return -(int)INIT_NAME_RESOLUTION_FAILURE; >+ } >+ >+ rfbsock = ConnectToTcpAddr(host, port); >+ if (rfbsock < 0) { >+ fprintf(stderr,"Unable to connect to VNC server\n"); >+ } >+ >+ return rfbsock; >+} >+ >+ >+/* >+ * InitialiseRFBConnection. >+ */ >+ >+enum InitStatus >+InitialiseRFBConnection() >+{ >+ rfbProtocolVersionMsg pv; >+ int major,minor; >+ CARD32 authScheme, reasonLen, authResult; >+ char *reason; >+ CARD8 challenge[CHALLENGESIZE]; >+ char passwd[9]; >+ int i; >+ rfbClientInitMsg ci; >+ >+ /* if the connection is immediately closed, don't report anything, so >+ that pmw's monitor can make test connections */ >+ >+ if (!ReadFromRFBServer(pv, sz_rfbProtocolVersionMsg)) return INIT_SERVER_BLOCKED; >+ >+ errorMessageOnReadFailure = True; >+ >+ pv[sz_rfbProtocolVersionMsg] = 0; >+ >+ if (sscanf(pv,rfbProtocolVersionFormat,&major,&minor) != 2) { >+ fprintf(stderr,"Not a valid VNC server\n"); >+ return INIT_PROTOCOL_FAILURE; >+ } >+ >+ fprintf(stderr,"VNC server supports protocol version %d.%d (viewer %d.%d)\n", >+ major, minor, rfbProtocolMajorVersion, rfbProtocolMinorVersion); >+ >+ major = rfbProtocolMajorVersion; >+ minor = rfbProtocolMinorVersion; >+ >+ sprintf(pv,rfbProtocolVersionFormat,major,minor); >+ >+ if (!WriteExact(rfbsock, pv, sz_rfbProtocolVersionMsg)) return INIT_CONNECTION_FAILED; >+ >+ if (!ReadFromRFBServer((char *)&authScheme, 4)) return INIT_CONNECTION_FAILED; >+ >+ authScheme = Swap32IfLE(authScheme); >+ >+ switch (authScheme) { >+ >+ case rfbConnFailed: >+ if (!ReadFromRFBServer((char *)&reasonLen, 4)) return INIT_CONNECTION_FAILED; >+ reasonLen = Swap32IfLE(reasonLen); >+ >+ if (reasonLen > MAX_STRING) { >+ fprintf(stderr, "Connection failure reason too long.\n"); >+ return INIT_CONNECTION_FAILED; >+ } >+ >+ reason = malloc(reasonLen); >+ if (!reason) >+ return INIT_CONNECTION_FAILED; >+ >+ if (!ReadFromRFBServer(reason, reasonLen)) return INIT_CONNECTION_FAILED; >+ >+ fprintf(stderr,"VNC connection failed: %.*s\n",(int)reasonLen, reason); >+ free(reason); >+ return INIT_CONNECTION_FAILED; >+ >+ case rfbNoAuth: >+ fprintf(stderr,"No authentication needed\n"); >+ break; >+ >+ case rfbVncAuth: >+ if (!ReadFromRFBServer((char *)challenge, CHALLENGESIZE)) return INIT_CONNECTION_FAILED; >+ >+ if (!getPassword(passwd, 8)) >+ return INIT_ABORTED; >+ >+ passwd[8] = '\0'; >+ >+ vncEncryptBytes(challenge, passwd); >+ >+ /* Lose the password from memory */ >+ for (i = strlen(passwd); i >= 0; i--) { >+ passwd[i] = '\0'; >+ } >+ >+ if (!WriteExact(rfbsock, (char *)challenge, CHALLENGESIZE)) return INIT_CONNECTION_FAILED; >+ >+ if (!ReadFromRFBServer((char *)&authResult, 4)) return INIT_CONNECTION_FAILED; >+ >+ authResult = Swap32IfLE(authResult); >+ >+ switch (authResult) { >+ case rfbVncAuthOK: >+ fprintf(stderr,"VNC authentication succeeded\n"); >+ break; >+ case rfbVncAuthFailed: >+ fprintf(stderr,"VNC authentication failed\n"); >+ return INIT_AUTHENTICATION_FAILED; >+ case rfbVncAuthTooMany: >+ fprintf(stderr,"VNC authentication failed - too many tries\n"); >+ return INIT_AUTHENTICATION_FAILED; >+ default: >+ fprintf(stderr,"Unknown VNC authentication result: %d\n", >+ (int)authResult); >+ return INIT_CONNECTION_FAILED; >+ } >+ break; >+ >+ default: >+ fprintf(stderr,"Unknown authentication scheme from VNC server: %d\n", >+ (int)authScheme); >+ return INIT_CONNECTION_FAILED; >+ } >+ >+ ci.shared = (appData.shareDesktop ? 1 : 0); >+ >+ if (!WriteExact(rfbsock, (char *)&ci, sz_rfbClientInitMsg)) return INIT_CONNECTION_FAILED; >+ >+ if (!ReadFromRFBServer((char *)&si, sz_rfbServerInitMsg)) return INIT_CONNECTION_FAILED; >+ >+ si.framebufferWidth = Swap16IfLE(si.framebufferWidth); >+ si.framebufferHeight = Swap16IfLE(si.framebufferHeight); >+ si.format.redMax = Swap16IfLE(si.format.redMax); >+ si.format.greenMax = Swap16IfLE(si.format.greenMax); >+ si.format.blueMax = Swap16IfLE(si.format.blueMax); >+ si.nameLength = Swap32IfLE(si.nameLength); >+ >+ if ((si.framebufferWidth*si.framebufferHeight) > (4096*4096)) >+ return INIT_CONNECTION_FAILED; >+ >+ if (si.nameLength > MAX_STRING) { >+ fprintf(stderr, "Display name too long.\n"); >+ return INIT_CONNECTION_FAILED; >+ } >+ >+ desktopName = malloc(si.nameLength + 1); >+ if (!desktopName) { >+ fprintf(stderr, "Error allocating memory for desktop name, %lu bytes\n", >+ (unsigned long)si.nameLength); >+ return INIT_CONNECTION_FAILED; >+ } >+ >+ if (!ReadFromRFBServer(desktopName, si.nameLength)) return INIT_CONNECTION_FAILED; >+ >+ desktopName[si.nameLength] = 0; >+ >+ fprintf(stderr,"Desktop name \"%s\"\n",desktopName); >+ >+ fprintf(stderr,"Connected to VNC server, using protocol version %d.%d\n", >+ rfbProtocolMajorVersion, rfbProtocolMinorVersion); >+ >+ fprintf(stderr,"VNC server default format:\n"); >+ PrintPixelFormat(&si.format); >+ >+ return INIT_OK; >+} >+ >+ >+/* >+ * SetFormatAndEncodings. >+ */ >+ >+Bool >+SetFormatAndEncodings() >+{ >+ rfbSetPixelFormatMsg spf; >+ char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4]; >+ rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf; >+ CARD32 *encs = (CARD32 *)(&buf[sz_rfbSetEncodingsMsg]); >+ int len = 0; >+ Bool requestCompressLevel = False; >+ Bool requestQualityLevel = False; >+ Bool requestLastRectEncoding = False; >+ >+ spf.type = rfbSetPixelFormat; >+ spf.pad1 = 0; >+ spf.pad2 = 0; >+ spf.format = myFormat; >+ spf.format.redMax = Swap16IfLE(spf.format.redMax); >+ spf.format.greenMax = Swap16IfLE(spf.format.greenMax); >+ spf.format.blueMax = Swap16IfLE(spf.format.blueMax); >+ >+ if (!WriteExact(rfbsock, (char *)&spf, sz_rfbSetPixelFormatMsg)) >+ return False; >+ >+ se->type = rfbSetEncodings; >+ se->pad = 0; >+ se->nEncodings = 0; >+ >+ if (appData.encodingsString) { >+ const char *encStr = appData.encodingsString; >+ int encStrLen; >+ do { >+ char *nextEncStr = strchr(encStr, ' '); >+ if (nextEncStr) { >+ encStrLen = nextEncStr - encStr; >+ nextEncStr++; >+ } else { >+ encStrLen = strlen(encStr); >+ } >+ >+ if (strncasecmp(encStr,"raw",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw); >+ } else if (strncasecmp(encStr,"copyrect",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect); >+ } else if (strncasecmp(encStr,"softcursor",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingSoftCursor); >+ /* if server supports SoftCursor, it will ignore X/RichCursor >+ * and PointerPos */ >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingXCursor); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRichCursor); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingPointerPos); >+ } else if (strncasecmp(encStr,"background",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingBackground); >+ } else if (strncasecmp(encStr,"tight",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight); >+ requestLastRectEncoding = True; >+ if (appData.compressLevel >= 0 && appData.compressLevel <= 9) >+ requestCompressLevel = True; >+ if (appData.qualityLevel >= 0 && appData.qualityLevel <= 9) >+ requestQualityLevel = True; >+ } else if (strncasecmp(encStr,"hextile",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile); >+ } else if (strncasecmp(encStr,"zlib",encStrLen) == 0) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib); >+ if (appData.compressLevel >= 0 && appData.compressLevel <= 9) >+ requestCompressLevel = True; >+ } else { >+ fprintf(stderr,"Unknown encoding '%.*s'\n",encStrLen,encStr); >+ } >+ >+ encStr = nextEncStr; >+ } while (encStr && se->nEncodings < MAX_ENCODINGS); >+ >+ if (se->nEncodings < MAX_ENCODINGS && requestCompressLevel) { >+ encs[se->nEncodings++] = Swap32IfLE(appData.compressLevel + >+ rfbEncodingCompressLevel0); >+ } >+ >+ if (se->nEncodings < MAX_ENCODINGS && requestQualityLevel) { >+ encs[se->nEncodings++] = Swap32IfLE(appData.qualityLevel + >+ rfbEncodingQualityLevel0); >+ } >+ >+ if (se->nEncodings < MAX_ENCODINGS && requestLastRectEncoding) { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect); >+ } >+ } >+ else { >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingCopyRect); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingTight); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingHextile); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingZlib); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingRaw); >+ >+ if (appData.compressLevel >= 0 && appData.compressLevel <= 9) { >+ encs[se->nEncodings++] = Swap32IfLE(appData.compressLevel + >+ rfbEncodingCompressLevel0); >+ } >+ >+ if (appData.qualityLevel >= 0 && appData.qualityLevel <= 9) { >+ encs[se->nEncodings++] = Swap32IfLE(appData.qualityLevel + >+ rfbEncodingQualityLevel0); >+ } >+ >+ if (si.format.depth >= 8) >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingSoftCursor); >+ encs[se->nEncodings++] = Swap32IfLE(rfbEncodingLastRect); >+ } >+ >+ len = sz_rfbSetEncodingsMsg + se->nEncodings * 4; >+ >+ se->nEncodings = Swap16IfLE(se->nEncodings); >+ >+ if (!WriteExact(rfbsock, buf, len)) return False; >+ >+ return True; >+} >+ >+ >+/* >+ * SendIncrementalFramebufferUpdateRequest. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+SendIncrementalFramebufferUpdateRequest() >+{ >+ return SendFramebufferUpdateRequest(0, 0, si.framebufferWidth, >+ si.framebufferHeight, True); >+} >+ >+ >+/* >+ * SendFramebufferUpdateRequest. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+SendFramebufferUpdateRequest(int x, int y, int w, int h, Bool incremental) >+{ >+ rfbFramebufferUpdateRequestMsg fur; >+ >+ fur.type = rfbFramebufferUpdateRequest; >+ fur.incremental = incremental ? 1 : 0; >+ fur.x = Swap16IfLE(x); >+ fur.y = Swap16IfLE(y); >+ fur.w = Swap16IfLE(w); >+ fur.h = Swap16IfLE(h); >+ >+ if (!WriteExact(rfbsock, (char *)&fur, sz_rfbFramebufferUpdateRequestMsg)) >+ return False; >+ >+ return True; >+} >+ >+ >+/* >+ * SendPointerEvent. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+SendPointerEvent(int x, int y, int buttonMask) >+{ >+ rfbPointerEventMsg pe; >+ >+ pe.type = rfbPointerEvent; >+ pe.buttonMask = buttonMask; >+ if (x < 0) x = 0; >+ if (y < 0) y = 0; >+ pe.x = Swap16IfLE(x); >+ pe.y = Swap16IfLE(y); >+ return WriteExact(rfbsock, (char *)&pe, sz_rfbPointerEventMsg); >+} >+ >+ >+/* >+ * SendKeyEvent. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+SendKeyEvent(CARD32 key, Bool down) >+{ >+ rfbKeyEventMsg ke; >+ >+ memset(&ke, 0, sizeof(ke)); >+ ke.type = rfbKeyEvent; >+ ke.down = down ? 1 : 0; >+ ke.key = Swap32IfLE(key); >+ return WriteExact(rfbsock, (char *)&ke, sz_rfbKeyEventMsg); >+} >+ >+ >+/* >+ * SendClientCutText. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+SendClientCutText(const char *str, int len) >+{ >+ rfbClientCutTextMsg cct; >+ >+ memset(&cct, 0, sizeof(cct)); >+ cct.type = rfbClientCutText; >+ cct.length = Swap32IfLE((unsigned int)len); >+ return (WriteExact(rfbsock, (char *)&cct, sz_rfbClientCutTextMsg) && >+ WriteExact(rfbsock, str, len)); >+} >+ >+ >+static Bool >+HandleSoftCursorSetImage(rfbSoftCursorSetImage *msg, rfbRectangle *rect) >+{ >+ int iindex = msg->imageIndex - rfbSoftCursorSetIconOffset; >+ PointerImage *pi = &pointerImages[iindex]; >+ if (iindex >= rfbSoftCursorMaxImages) { >+ fprintf(stderr, "Received invalid soft cursor image index %d for SetImage\n", iindex); >+ return False; >+ } >+ EnableClientCursor(0); >+ >+ if (pi->set && pi->image) >+ free(pi->image); >+ >+ pi->w = rect->w; >+ pi->h = rect->h; >+ pi->hotX = rect->x; >+ pi->hotY = rect->y; >+ pi->len = Swap16IfLE(msg->imageLength); >+ pi->image = malloc(pi->len); >+ if (!pi->image) { >+ fprintf(stderr, "out of memory (size=%d)\n", pi->len); >+ return False; >+ } >+ >+ if (!ReadFromRFBServer(pi->image, pi->len)) >+ return False; >+ pi->set = 1; >+ return True; >+} >+ >+/* framebuffer must be locked when calling this!!! */ >+static Bool >+PointerMove(unsigned int x, unsigned int y, unsigned int mask, >+ int ox, int oy, int ow, int oh) >+{ >+ int nx, ny, nw, nh; >+ >+ if (x >= si.framebufferWidth) >+ x = si.framebufferWidth - 1; >+ if (y >= si.framebufferHeight) >+ y = si.framebufferHeight - 1; >+ >+ cursorX = x; >+ cursorY = y; >+ drawCursor(); >+ UnlockFramebuffer(); >+ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &nx, &ny, &nw, &nh); >+ >+ if (rectsIntersect(ox, oy, ow, oh, nx, ny, nw, nh)) { >+ rectsJoin(&ox, &oy, &ow, &oh, nx, ny, nw, nh); >+ SyncScreenRegion(ox, oy, ow, oh); >+ } >+ else { >+ SyncScreenRegion(ox, oy, ow, oh); >+ SyncScreenRegion(nx, ny, nw, nh); >+ } >+ >+ postMouseEvent(cursorX, cursorY, mask); >+ >+ return True; >+} >+ >+static Bool >+HandleSoftCursorMove(rfbSoftCursorMove *msg, rfbRectangle *rect) >+{ >+ int ii, ox, oy, ow, oh; >+ >+ /* get old cursor rect to know what to update */ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &ox, &oy, &ow, &oh); >+ >+ ii = msg->imageIndex; >+ if (ii >= rfbSoftCursorMaxImages) { >+ fprintf(stderr, "Received invalid soft cursor image index %d for Move\n", ii); >+ return False; >+ } >+ >+ if (!pointerImages[ii].set) >+ return True; >+ >+ LockFramebuffer(); >+ undrawCursor(); >+ imageIndex = ii; >+ >+ return PointerMove(rect->w, rect->h, msg->buttonMask, ox, oy, ow, oh); >+} >+ >+static Bool >+HandleCursorPos(unsigned int x, unsigned int y) >+{ >+ int ox, oy, ow, oh; >+ >+ /* get old cursor rect to know what to update */ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &ox, &oy, &ow, &oh); >+ if (!pointerImages[0].set) >+ return True; >+ >+ LockFramebuffer(); >+ undrawCursor(); >+ imageIndex = 0; >+ return PointerMove(x, y, 0, ox, oy, ow, oh); >+} >+ >+/* call only from X11 thread. Only updates framebuffer, does not sync! */ >+void DrawCursorX11Thread(int x, int y) { >+ int ox, oy, ow, oh, nx, ny, nw, nh; >+ if (!pointerImages[0].set) >+ return; >+ imageIndex = 0; >+ >+ if (x >= si.framebufferWidth) >+ x = si.framebufferWidth - 1; >+ if (y >= si.framebufferHeight) >+ y = si.framebufferHeight - 1; >+ >+ LockFramebuffer(); >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &ox, &oy, &ow, &oh); >+ undrawCursor(); >+ cursorX = x; >+ cursorY = y; >+ drawCursor(); >+ UnlockFramebuffer(); >+ >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &nx, &ny, &nw, &nh); >+ if (rectsIntersect(ox, oy, ow, oh, nx, ny, nw, nh)) { >+ rectsJoin(&ox, &oy, &ow, &oh, nx, ny, nw, nh); >+ SyncScreenRegionX11Thread(ox, oy, ow, oh); >+ } >+ else { >+ SyncScreenRegionX11Thread(ox, oy, ow, oh); >+ SyncScreenRegionX11Thread(nx, ny, nw, nh); >+ } >+} >+ >+/** >+ * Create a softcursor in the "compressed alpha" format. >+ * Returns the softcursor, caller owns the object >+ */ >+static void *MakeSoftCursor(int bpp, int cursorWidth, int cursorHeight, >+ CARD8 *cursorData, CARD8 *cursorMask, short *imageLen) >+{ >+ int w = (cursorWidth+7)/8; >+ unsigned char *cp, *sp, *dstData; >+ int state; /* 0 = transparent, 1 otherwise */ >+ CARD8 *counter; >+ unsigned char bit; >+ int i,j; >+ >+ sp = (unsigned char*)cursorData; >+ dstData = cp = (unsigned char*)calloc(cursorWidth*(bpp+2),cursorHeight); >+ if (!dstData) >+ return 0; >+ >+ state = 0; >+ counter = cp++; >+ *counter = 0; >+ >+ for(j=0;j<cursorHeight;j++) >+ for(i=0,bit=0x80;i<cursorWidth;i++,bit=(bit&1)?0x80:bit>>1) >+ if(cursorMask[j*w+i/8]&bit) { >+ if (state) { >+ memcpy(cp,sp,bpp); >+ cp += bpp; >+ sp += bpp; >+ (*counter)++; >+ if (*counter == 255) { >+ state = 0; >+ counter = cp++; >+ *counter = 0; >+ } >+ } >+ else { >+ state = 1; >+ counter = cp++; >+ *counter = 1; >+ memcpy(cp,sp,bpp); >+ cp += bpp; >+ sp += bpp; >+ } >+ } >+ else { >+ if (!state) { >+ (*counter)++; >+ if (*counter == 255) { >+ state = 1; >+ counter = cp++; >+ *counter = 0; >+ } >+ } >+ else { >+ state = 0; >+ counter = cp++; >+ *counter = 1; >+ } >+ sp += bpp; >+ } >+ >+ *imageLen = cp - dstData; >+ return (void*) dstData; >+} >+ >+ >+/********************************************************************* >+ * HandleCursorShape(). Support for XCursor and RichCursor shape >+ * updates. We emulate cursor operating on the frame buffer (that is >+ * why we call it "software cursor"). >+ ********************************************************************/ >+ >+static Bool HandleCursorShape(int xhot, int yhot, int width, int height, CARD32 enc) >+{ >+ int bytesPerPixel; >+ size_t bytesPerRow, bytesMaskData; >+ rfbXCursorColors rgb; >+ CARD32 colors[2]; >+ CARD8 *ptr, *rcSource, *rcMask; >+ void *softCursor; >+ int x, y, b; >+ int ox, oy, ow, oh; >+ PointerImage *pi; >+ short imageLen; >+ >+ bytesPerPixel = myFormat.bitsPerPixel / 8; >+ bytesPerRow = (width + 7) / 8; >+ bytesMaskData = bytesPerRow * height; >+ >+ if (width * height == 0) >+ return True; >+ >+ /* Allocate memory for pixel data and temporary mask data. */ >+ >+ rcSource = malloc(width * height * bytesPerPixel); >+ if (rcSource == NULL) >+ return False; >+ >+ rcMask = malloc(bytesMaskData); >+ if (rcMask == NULL) { >+ free(rcSource); >+ return False; >+ } >+ >+ /* Read and decode cursor pixel data, depending on the encoding type. */ >+ >+ if (enc == rfbEncodingXCursor) { >+ /* Read and convert background and foreground colors. */ >+ if (!ReadFromRFBServer((char *)&rgb, sz_rfbXCursorColors)) { >+ free(rcSource); >+ free(rcMask); >+ return False; >+ } >+ colors[0] = RGB24_TO_PIXEL(32, rgb.backRed, rgb.backGreen, rgb.backBlue); >+ colors[1] = RGB24_TO_PIXEL(32, rgb.foreRed, rgb.foreGreen, rgb.foreBlue); >+ >+ /* Read 1bpp pixel data into a temporary buffer. */ >+ if (!ReadFromRFBServer((char*)rcMask, bytesMaskData)) { >+ free(rcSource); >+ free(rcMask); >+ return False; >+ } >+ >+ /* Convert 1bpp data to byte-wide color indices. */ >+ ptr = rcSource; >+ for (y = 0; y < height; y++) { >+ for (x = 0; x < width / 8; x++) { >+ for (b = 7; b >= 0; b--) { >+ *ptr = rcMask[y * bytesPerRow + x] >> b & 1; >+ ptr += bytesPerPixel; >+ } >+ } >+ for (b = 7; b > 7 - width % 8; b--) { >+ *ptr = rcMask[y * bytesPerRow + x] >> b & 1; >+ ptr += bytesPerPixel; >+ } >+ } >+ >+ /* Convert indices into the actual pixel values. */ >+ switch (bytesPerPixel) { >+ case 1: >+ for (x = 0; x < width * height; x++) >+ rcSource[x] = (CARD8)colors[rcSource[x]]; >+ break; >+ case 2: >+ for (x = 0; x < width * height; x++) >+ ((CARD16 *)rcSource)[x] = (CARD16)colors[rcSource[x * 2]]; >+ break; >+ case 4: >+ for (x = 0; x < width * height; x++) >+ ((CARD32 *)rcSource)[x] = colors[rcSource[x * 4]]; >+ break; >+ } >+ >+ >+ } else { >+ if (!ReadFromRFBServer((char *)rcSource, width * height * bytesPerPixel)) { >+ free(rcSource); >+ free(rcMask); >+ return False; >+ } >+ } >+ >+ /* Read mask data. */ >+ >+ if (!ReadFromRFBServer((char*)rcMask, bytesMaskData)) { >+ free(rcSource); >+ free(rcMask); >+ return False; >+ } >+ >+ >+ /* Set the soft cursor. */ >+ softCursor = MakeSoftCursor(bytesPerPixel, width, height, rcSource, rcMask, &imageLen); >+ if (!softCursor) { >+ free(rcMask); >+ free(rcSource); >+ return False; >+ } >+ >+ /* get old cursor rect to know what to update */ >+ EnableClientCursor(1); >+ LockFramebuffer(); >+ getBoundingRectCursor(cursorX, cursorY, imageIndex, >+ &ox, &oy, &ow, &oh); >+ undrawCursor(); >+ >+ pi = &pointerImages[0]; >+ if (pi->set && pi->image) >+ free(pi->image); >+ pi->w = width; >+ pi->h = height; >+ pi->hotX = xhot; >+ pi->hotY = yhot; >+ pi->len = imageLen; >+ pi->image = softCursor; >+ pi->set = 1; >+ >+ imageIndex = 0; >+ >+ free(rcMask); >+ free(rcSource); >+ >+ return PointerMove(cursorX, cursorY, 0, ox, oy, ow, oh); >+} >+ >+ >+ >+/* >+ * HandleRFBServerMessage. >+ */ >+ >+Bool >+HandleRFBServerMessage() >+{ >+ rfbServerToClientMsg msg; >+ if (!ReadFromRFBServer((char *)&msg, 1)) >+ return False; >+ >+ switch (msg.type) { >+ >+ case rfbSetColourMapEntries: >+ { >+ int i; >+ CARD16 rgb[3]; >+ XColor xc; >+ >+ if (!ReadFromRFBServer(((char *)&msg) + 1, >+ sz_rfbSetColourMapEntriesMsg - 1)) >+ return False; >+ >+ msg.scme.firstColour = Swap16IfLE(msg.scme.firstColour); >+ msg.scme.nColours = Swap16IfLE(msg.scme.nColours); >+ >+ for (i = 0; i < msg.scme.nColours; i++) { >+ if (!ReadFromRFBServer((char *)rgb, 6)) >+ return False; >+ xc.pixel = msg.scme.firstColour + i; >+ xc.red = Swap16IfLE(rgb[0]); >+ xc.green = Swap16IfLE(rgb[1]); >+ xc.blue = Swap16IfLE(rgb[2]); >+ xc.flags = DoRed|DoGreen|DoBlue; >+ /* Disable colormaps >+ lockTQt(); >+ XStoreColor(dpy, cmap, &xc); >+ unlockTQt(); >+ */ >+ } >+ >+ break; >+ } >+ >+ case rfbFramebufferUpdate: >+ { >+ rfbFramebufferUpdateRectHeader rect; >+ int linesToRead; >+ int bytesPerLine; >+ int i; >+ >+ announceIncrementalUpdateRequest(); >+ >+ if (!ReadFromRFBServer(((char *)&msg.fu) + 1, >+ sz_rfbFramebufferUpdateMsg - 1)) >+ return False; >+ >+ msg.fu.nRects = Swap16IfLE(msg.fu.nRects); >+ >+ for (i = 0; i < msg.fu.nRects; i++) { >+ if (!ReadFromRFBServer((char *)&rect, sz_rfbFramebufferUpdateRectHeader)) >+ return False; >+ >+ rect.encoding = Swap32IfLE(rect.encoding); >+ if (rect.encoding == rfbEncodingLastRect) >+ break; >+ >+ rect.r.x = Swap16IfLE(rect.r.x); >+ rect.r.y = Swap16IfLE(rect.r.y); >+ rect.r.w = Swap16IfLE(rect.r.w); >+ rect.r.h = Swap16IfLE(rect.r.h); >+ >+ if (rect.encoding == rfbEncodingPointerPos) { >+ if (!HandleCursorPos(rect.r.x, rect.r.y)) { >+ return False; >+ } >+ continue; >+ } >+ >+ if (rect.encoding == rfbEncodingXCursor || >+ rect.encoding == rfbEncodingRichCursor) { >+ if (!HandleCursorShape(rect.r.x, rect.r.y, rect.r.w, rect.r.h, >+ rect.encoding)) { >+ return False; >+ } >+ continue; >+ } >+ >+ if ((rect.r.x + rect.r.w > si.framebufferWidth) || >+ (rect.r.y + rect.r.h > si.framebufferHeight)) >+ { >+ fprintf(stderr,"Rect too large: %dx%d at (%d, %d)\n", >+ rect.r.w, rect.r.h, rect.r.x, rect.r.y); >+ return False; >+ } >+ >+ if ((rect.r.h * rect.r.w == 0) && >+ (rect.encoding != rfbEncodingSoftCursor)) { >+ fprintf(stderr,"Zero size rect - ignoring\n"); >+ continue; >+ } >+ >+ switch (rect.encoding) { >+ >+ case rfbEncodingRaw: >+ >+ bytesPerLine = rect.r.w * myFormat.bitsPerPixel / 8; >+ /* RealVNC 4.x-5.x on OSX can induce bytesPerLine==0, >+ usually during GPU accel. */ >+ /* Regardless of cause, do not divide by zero. */ >+ linesToRead = bytesPerLine ? (BUFFER_SIZE / bytesPerLine) : 0; >+ >+ while (linesToRead && rect.r.h > 0) { >+ if (linesToRead > rect.r.h) >+ linesToRead = rect.r.h; >+ >+ if (!ReadFromRFBServer(buffer,bytesPerLine * linesToRead)) >+ return False; >+ >+ CopyDataToScreen(buffer, rect.r.x, rect.r.y, rect.r.w, >+ linesToRead); >+ >+ rect.r.h -= linesToRead; >+ rect.r.y += linesToRead; >+ >+ } >+ break; >+ >+ case rfbEncodingCopyRect: >+ { >+ rfbCopyRect cr; >+ >+ if (!ReadFromRFBServer((char *)&cr, sz_rfbCopyRect)) >+ return False; >+ >+ cr.srcX = Swap16IfLE(cr.srcX); >+ cr.srcY = Swap16IfLE(cr.srcY); >+ >+ CopyArea(cr.srcX, cr.srcY, rect.r.w, rect.r.h, rect.r.x, rect.r.y); >+ >+ break; >+ } >+ >+ case rfbEncodingHextile: >+ { >+ switch (myFormat.bitsPerPixel) { >+ case 8: >+ if (!HandleHextile8(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 16: >+ if (!HandleHextile16(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 32: >+ if (!HandleHextile32(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ } >+ break; >+ } >+ >+ case rfbEncodingZlib: >+ { >+ switch (myFormat.bitsPerPixel) { >+ case 8: >+ if (!HandleZlib8(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 16: >+ if (!HandleZlib16(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 32: >+ if (!HandleZlib32(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ } >+ break; >+ } >+ >+ case rfbEncodingTight: >+ { >+ switch (myFormat.bitsPerPixel) { >+ case 8: >+ if (!HandleTight8(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 16: >+ if (!HandleTight16(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ case 32: >+ if (!HandleTight32(rect.r.x,rect.r.y,rect.r.w,rect.r.h)) >+ return False; >+ break; >+ } >+ break; >+ } >+ >+ case rfbEncodingSoftCursor: >+ { >+ rfbSoftCursorMsg scmsg; >+ if (!ReadFromRFBServer((char *)&scmsg, 1)) >+ return False; >+ if (scmsg.type < rfbSoftCursorMaxImages) { >+ if (!ReadFromRFBServer(((char *)&scmsg)+1, >+ sizeof(rfbSoftCursorMove)- 1)) >+ return False; >+ if (!HandleSoftCursorMove(&scmsg.move, &rect.r)) >+ return False; >+ } >+ else if((scmsg.type >= rfbSoftCursorSetIconOffset) && >+ (scmsg.type < rfbSoftCursorSetIconOffset+rfbSoftCursorMaxImages)) { >+ if (!ReadFromRFBServer(((char *)&scmsg)+1, >+ sizeof(rfbSoftCursorSetImage)- 1)) >+ return False; >+ if (!HandleSoftCursorSetImage(&scmsg.setImage, &rect.r)) >+ return False; >+ } >+ else { >+ fprintf(stderr,"Unknown soft cursor image index %d\n", >+ (int)scmsg.type); >+ return False; >+ } >+ break; >+ } >+ >+ default: >+ fprintf(stderr,"Unknown rect encoding %d\n", >+ (int)rect.encoding); >+ return False; >+ } >+ >+ } >+ >+ queueIncrementalUpdateRequest(); >+ >+ break; >+ } >+ >+ case rfbBell: >+ { >+ beep(); >+ break; >+ } >+ >+ case rfbServerCutText: >+ { >+ char *serverCutText; >+ if (!ReadFromRFBServer(((char *)&msg) + 1, >+ sz_rfbServerCutTextMsg - 1)) >+ return False; >+ >+ msg.sct.length = Swap32IfLE(msg.sct.length); >+ >+ if (msg.sct.length > MAX_CUTBUFFER) { >+ fprintf(stderr, "Cutbuffer too long.\n"); >+ return False; >+ } >+ >+ serverCutText = malloc(msg.sct.length+1); >+ >+ if (!serverCutText) { >+ fprintf(stderr, "Out-of-memory, cutbuffer too long.\n"); >+ return False; >+ } >+ >+ if (!ReadFromRFBServer(serverCutText, msg.sct.length)) { >+ free(serverCutText); >+ return False; >+ } >+ >+ serverCutText[msg.sct.length] = 0; >+ newServerCut(serverCutText, msg.sct.length); /* takes ownership of serverCutText */ >+ >+ break; >+ } >+ >+ default: >+ fprintf(stderr,"Unknown message type %d from VNC server\n",msg.type); >+ return False; >+ } >+ >+ return True; >+} >+ >+ >+#define GET_PIXEL8(pix, ptr) ((pix) = *(ptr)++) >+ >+#define GET_PIXEL16(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \ >+ ((CARD8*)&(pix))[1] = *(ptr)++) >+ >+#define GET_PIXEL32(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \ >+ ((CARD8*)&(pix))[1] = *(ptr)++, \ >+ ((CARD8*)&(pix))[2] = *(ptr)++, \ >+ ((CARD8*)&(pix))[3] = *(ptr)++) >+ >+/* CONCAT2 concatenates its two arguments. CONCAT2E does the same but also >+ expands its arguments if they are macros */ >+ >+#define CONCAT2(a,b) a##b >+#define CONCAT2E(a,b) CONCAT2(a,b) >+ >+#define BPP 8 >+#include "hextile.c" >+#include "zlib.c" >+#include "tight.c" >+#undef BPP >+#define BPP 16 >+#include "hextile.c" >+#include "zlib.c" >+#include "tight.c" >+#undef BPP >+#define BPP 32 >+#include "hextile.c" >+#include "zlib.c" >+#include "tight.c" >+#undef BPP >+ >+ >+/* >+ * PrintPixelFormat. >+ */ >+ >+void >+PrintPixelFormat(format) >+ rfbPixelFormat *format; >+{ >+ if (format->bitsPerPixel == 1) { >+ fprintf(stderr," Single bit per pixel.\n"); >+ fprintf(stderr, >+ " %s significant bit in each byte is leftmost on the screen.\n", >+ (format->bigEndian ? "Most" : "Least")); >+ } else { >+ fprintf(stderr," %d bits per pixel.\n",format->bitsPerPixel); >+ if (format->bitsPerPixel != 8) { >+ fprintf(stderr," %s significant byte first in each pixel.\n", >+ (format->bigEndian ? "Most" : "Least")); >+ } >+ if (format->trueColour) { >+ fprintf(stderr," True colour: max red %d green %d blue %d", >+ format->redMax, format->greenMax, format->blueMax); >+ fprintf(stderr,", shift red %d green %d blue %d\n", >+ format->redShift, format->greenShift, format->blueShift); >+ } else { >+ fprintf(stderr," Colour map (not true colour).\n"); >+ } >+ } >+} >+ >+static long >+ReadCompactLen (void) >+{ >+ long len; >+ CARD8 b; >+ >+ if (!ReadFromRFBServer((char *)&b, 1)) >+ return -1; >+ len = (int)b & 0x7F; >+ if (b & 0x80) { >+ if (!ReadFromRFBServer((char *)&b, 1)) >+ return -1; >+ len |= ((int)b & 0x7F) << 7; >+ if (b & 0x80) { >+ if (!ReadFromRFBServer((char *)&b, 1)) >+ return -1; >+ len |= ((int)b & 0xFF) << 14; >+ } >+ } >+ return len; >+} >+ >+void freeRFBProtoResources() { >+ int i; >+ >+ if (desktopName) >+ free(desktopName); >+ if (raw_buffer) >+ free(raw_buffer); >+ for (i = 0; i < rfbSoftCursorMaxImages; i++) >+ if (pointerImages[i].set && pointerImages[i].image) >+ free(pointerImages[i].image); >+ >+ raw_buffer_size = -1; >+ raw_buffer = NULL; >+ decompStreamInited = False; >+ zlibStreamActive[0] = False; >+ zlibStreamActive[1] = False; >+ zlibStreamActive[2] = False; >+ zlibStreamActive[3] = False; >+ for (i = 0; i < rfbSoftCursorMaxImages; i++) >+ pointerImages[i].set = 0; >+ imageIndex = -1; >+} >+ >+void freeResources() { >+ freeSocketsResources(); >+ freeDesktopResources(); >+ freeRFBProtoResources(); >+} >+ >+/* >+ * JPEG source manager functions for JPEG decompression in Tight decoder. >+ */ >+ >+static struct jpeg_source_mgr jpegSrcManager; >+static JOCTET *jpegBufferPtr; >+static size_t jpegBufferLen; >+ >+static void >+JpegInitSource(j_decompress_ptr cinfo) >+{ >+ jpegError = False; >+} >+ >+static boolean >+JpegFillInputBuffer(j_decompress_ptr cinfo) >+{ >+ jpegError = True; >+ jpegSrcManager.bytes_in_buffer = jpegBufferLen; >+ jpegSrcManager.next_input_byte = (JOCTET *)jpegBufferPtr; >+ >+ return TRUE; >+} >+ >+static void >+JpegSkipInputData(j_decompress_ptr cinfo, long num_bytes) >+{ >+ if (num_bytes < 0 || num_bytes > jpegSrcManager.bytes_in_buffer) { >+ jpegError = True; >+ jpegSrcManager.bytes_in_buffer = jpegBufferLen; >+ jpegSrcManager.next_input_byte = (JOCTET *)jpegBufferPtr; >+ } else { >+ jpegSrcManager.next_input_byte += (size_t) num_bytes; >+ jpegSrcManager.bytes_in_buffer -= (size_t) num_bytes; >+ } >+} >+ >+static void >+JpegTermSource(j_decompress_ptr cinfo) >+{ >+ /* No work necessary here. */ >+} >+ >+static void >+JpegSetSrcManager(j_decompress_ptr cinfo, CARD8 *compressedData, >+ int compressedLen) >+{ >+ jpegBufferPtr = (JOCTET *)compressedData; >+ jpegBufferLen = (size_t)compressedLen; >+ >+ jpegSrcManager.init_source = JpegInitSource; >+ jpegSrcManager.fill_input_buffer = JpegFillInputBuffer; >+ jpegSrcManager.skip_input_data = JpegSkipInputData; >+ jpegSrcManager.resync_to_restart = jpeg_resync_to_restart; >+ jpegSrcManager.term_source = JpegTermSource; >+ jpegSrcManager.next_input_byte = jpegBufferPtr; >+ jpegSrcManager.bytes_in_buffer = jpegBufferLen; >+ >+ cinfo->src = &jpegSrcManager; >+} >+ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/rfbproto.h tdenetwork-trinity-14.1.0/krdc/vnc/rfbproto.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/rfbproto.h 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/rfbproto.h 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,957 @@ >+/* >+ * Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved. >+ * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * rfbproto.h - header file for the RFB protocol version 3.3 >+ * >+ * Uses types CARD<n> for an n-bit unsigned integer, INT<n> for an n-bit signed >+ * integer (for n = 8, 16 and 32). >+ * >+ * All multiple byte integers are in big endian (network) order (most >+ * significant byte first). Unless noted otherwise there is no special >+ * alignment of protocol structures. >+ * >+ * >+ * Once the initial handshaking is done, all messages start with a type byte, >+ * (usually) followed by message-specific data. The order of definitions in >+ * this file is as follows: >+ * >+ * (1) Structures used in several types of message. >+ * (2) Structures used in the initial handshaking. >+ * (3) Message types. >+ * (4) Encoding types. >+ * (5) For each message type, the form of the data following the type byte. >+ * Sometimes this is defined by a single structure but the more complex >+ * messages have to be explained by comments. >+ */ >+ >+#include "vnctypes.h" >+ >+/***************************************************************************** >+ * >+ * Structures used in several messages >+ * >+ *****************************************************************************/ >+ >+/*----------------------------------------------------------------------------- >+ * Structure used to specify a rectangle. This structure is a multiple of 4 >+ * bytes so that it can be interspersed with 32-bit pixel data without >+ * affecting alignment. >+ */ >+ >+typedef struct { >+ CARD16 x; >+ CARD16 y; >+ CARD16 w; >+ CARD16 h; >+} rfbRectangle; >+ >+#define sz_rfbRectangle 8 >+ >+ >+/*----------------------------------------------------------------------------- >+ * Structure used to specify pixel format. >+ */ >+ >+typedef struct { >+ >+ CARD8 bitsPerPixel; /* 8,16,32 only */ >+ >+ CARD8 depth; /* 8 to 32 */ >+ >+ CARD8 bigEndian; /* True if multi-byte pixels are interpreted >+ as big endian, or if single-bit-per-pixel >+ has most significant bit of the byte >+ corresponding to first (leftmost) pixel. Of >+ course this is meaningless for 8 bits/pix */ >+ >+ CARD8 trueColour; /* If false then we need a "colour map" to >+ convert pixels to RGB. If true, xxxMax and >+ xxxShift specify bits used for red, green >+ and blue */ >+ >+ /* the following fields are only meaningful if trueColour is true */ >+ >+ CARD16 redMax; /* maximum red value (= 2^n - 1 where n is the >+ number of bits used for red). Note this >+ value is always in big endian order. */ >+ >+ CARD16 greenMax; /* similar for green */ >+ >+ CARD16 blueMax; /* and blue */ >+ >+ CARD8 redShift; /* number of shifts needed to get the red >+ value in a pixel to the least significant >+ bit. To find the red value from a given >+ pixel, do the following: >+ 1) Swap pixel value according to bigEndian >+ (e.g. if bigEndian is false and host byte >+ order is big endian, then swap). >+ 2) Shift right by redShift. >+ 3) AND with redMax (in host byte order). >+ 4) You now have the red value between 0 and >+ redMax. */ >+ >+ CARD8 greenShift; /* similar for green */ >+ >+ CARD8 blueShift; /* and blue */ >+ >+ CARD8 pad1; >+ CARD16 pad2; >+ >+} rfbPixelFormat; >+ >+#define sz_rfbPixelFormat 16 >+ >+ >+ >+/***************************************************************************** >+ * >+ * Initial handshaking messages >+ * >+ *****************************************************************************/ >+ >+/*----------------------------------------------------------------------------- >+ * Protocol Version >+ * >+ * The server always sends 12 bytes to start which identifies the latest RFB >+ * protocol version number which it supports. These bytes are interpreted >+ * as a string of 12 ASCII characters in the format "RFB xxx.yyy\n" where >+ * xxx and yyy are the major and minor version numbers (for version 3.3 >+ * this is "RFB 003.003\n"). >+ * >+ * The client then replies with a similar 12-byte message giving the version >+ * number of the protocol which should actually be used (which may be different >+ * to that quoted by the server). >+ * >+ * It is intended that both clients and servers may provide some level of >+ * backwards compatibility by this mechanism. Servers in particular should >+ * attempt to provide backwards compatibility, and even forwards compatibility >+ * to some extent. For example if a client demands version 3.1 of the >+ * protocol, a 3.0 server can probably assume that by ignoring requests for >+ * encoding types it doesn't understand, everything will still work OK. This >+ * will probably not be the case for changes in the major version number. >+ * >+ * The format string below can be used in sprintf or sscanf to generate or >+ * decode the version string respectively. >+ */ >+ >+#define rfbProtocolVersionFormat "RFB %03d.%03d\n" >+#define rfbProtocolMajorVersion 3 >+#define rfbProtocolMinorVersion 3 >+ >+typedef char rfbProtocolVersionMsg[13]; /* allow extra byte for null */ >+ >+#define sz_rfbProtocolVersionMsg 12 >+ >+ >+/*----------------------------------------------------------------------------- >+ * Authentication >+ * >+ * Once the protocol version has been decided, the server then sends a 32-bit >+ * word indicating whether any authentication is needed on the connection. >+ * The value of this word determines the authentication scheme in use. For >+ * version 3.0 of the protocol this may have one of the following values: >+ */ >+ >+#define rfbConnFailed 0 >+#define rfbNoAuth 1 >+#define rfbVncAuth 2 >+ >+/* >+ * rfbConnFailed: For some reason the connection failed (e.g. the server >+ * cannot support the desired protocol version). This is >+ * followed by a string describing the reason (where a >+ * string is specified as a 32-bit length followed by that >+ * many ASCII characters). >+ * >+ * rfbNoAuth: No authentication is needed. >+ * >+ * rfbVncAuth: The VNC authentication scheme is to be used. A 16-byte >+ * challenge follows, which the client encrypts as >+ * appropriate using the password and sends the resulting >+ * 16-byte response. If the response is correct, the >+ * server sends the 32-bit word rfbVncAuthOK. If a simple >+ * failure happens, the server sends rfbVncAuthFailed and >+ * closes the connection. If the server decides that too >+ * many failures have occurred, it sends rfbVncAuthTooMany >+ * and closes the connection. In the latter case, the >+ * server should not allow an immediate reconnection by >+ * the client. >+ */ >+ >+#define rfbVncAuthOK 0 >+#define rfbVncAuthFailed 1 >+#define rfbVncAuthTooMany 2 >+ >+ >+/*----------------------------------------------------------------------------- >+ * Client Initialisation Message >+ * >+ * Once the client and server are sure that they're happy to talk to one >+ * another, the client sends an initialisation message. At present this >+ * message only consists of a boolean indicating whether the server should try >+ * to share the desktop by leaving other clients connected, or give exclusive >+ * access to this client by disconnecting all other clients. >+ */ >+ >+typedef struct { >+ CARD8 shared; >+} rfbClientInitMsg; >+ >+#define sz_rfbClientInitMsg 1 >+ >+ >+/*----------------------------------------------------------------------------- >+ * Server Initialisation Message >+ * >+ * After the client initialisation message, the server sends one of its own. >+ * This tells the client the width and height of the server's framebuffer, >+ * its pixel format and the name associated with the desktop. >+ */ >+ >+typedef struct { >+ CARD16 framebufferWidth; >+ CARD16 framebufferHeight; >+ rfbPixelFormat format; /* the server's preferred pixel format */ >+ CARD32 nameLength; >+ /* followed by char name[nameLength] */ >+} rfbServerInitMsg; >+ >+#define sz_rfbServerInitMsg (8 + sz_rfbPixelFormat) >+ >+ >+/* >+ * Following the server initialisation message it's up to the client to send >+ * whichever protocol messages it wants. Typically it will send a >+ * SetPixelFormat message and a SetEncodings message, followed by a >+ * FramebufferUpdateRequest. From then on the server will send >+ * FramebufferUpdate messages in response to the client's >+ * FramebufferUpdateRequest messages. The client should send >+ * FramebufferUpdateRequest messages with incremental set to true when it has >+ * finished processing one FramebufferUpdate and is ready to process another. >+ * With a fast client, the rate at which FramebufferUpdateRequests are sent >+ * should be regulated to avoid hogging the network. >+ */ >+ >+ >+ >+/***************************************************************************** >+ * >+ * Message types >+ * >+ *****************************************************************************/ >+ >+/* server -> client */ >+ >+#define rfbFramebufferUpdate 0 >+#define rfbSetColourMapEntries 1 >+#define rfbBell 2 >+#define rfbServerCutText 3 >+ >+ >+/* client -> server */ >+ >+#define rfbSetPixelFormat 0 >+#define rfbFixColourMapEntries 1 /* not currently supported */ >+#define rfbSetEncodings 2 >+#define rfbFramebufferUpdateRequest 3 >+#define rfbKeyEvent 4 >+#define rfbPointerEvent 5 >+#define rfbClientCutText 6 >+ >+ >+ >+ >+/***************************************************************************** >+ * >+ * Encoding types >+ * >+ *****************************************************************************/ >+ >+#define rfbEncodingRaw 0 >+#define rfbEncodingCopyRect 1 >+#define rfbEncodingRRE 2 >+#define rfbEncodingCoRRE 4 >+#define rfbEncodingHextile 5 >+#define rfbEncodingZlib 6 >+#define rfbEncodingTight 7 >+#define rfbEncodingZlibHex 8 >+ >+/* >+ * Special encoding numbers: >+ * 0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels; >+ * 0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data; >+ * 0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions; >+ * 0xFFFFFF30 .. 0xFFFFFFDF -- not allocated yet; >+ * 0xFFFFFFE0 .. 0xFFFFFFEF -- quality level for JPEG compressor; >+ * 0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels. >+ */ >+ >+#define rfbEncodingCompressLevel0 0xFFFFFF00 >+#define rfbEncodingCompressLevel1 0xFFFFFF01 >+#define rfbEncodingCompressLevel2 0xFFFFFF02 >+#define rfbEncodingCompressLevel3 0xFFFFFF03 >+#define rfbEncodingCompressLevel4 0xFFFFFF04 >+#define rfbEncodingCompressLevel5 0xFFFFFF05 >+#define rfbEncodingCompressLevel6 0xFFFFFF06 >+#define rfbEncodingCompressLevel7 0xFFFFFF07 >+#define rfbEncodingCompressLevel8 0xFFFFFF08 >+#define rfbEncodingCompressLevel9 0xFFFFFF09 >+ >+#define rfbEncodingXCursor 0xFFFFFF10 >+#define rfbEncodingRichCursor 0xFFFFFF11 >+#define rfbEncodingSoftCursor 0xFFFFFF12 >+#define rfbEncodingPointerPos 0xFFFFFF18 >+ >+#define rfbEncodingLastRect 0xFFFFFF20 >+#define rfbEncodingBackground 0xFFFFFF25 >+ >+#define rfbEncodingQualityLevel0 0xFFFFFFE0 >+#define rfbEncodingQualityLevel1 0xFFFFFFE1 >+#define rfbEncodingQualityLevel2 0xFFFFFFE2 >+#define rfbEncodingQualityLevel3 0xFFFFFFE3 >+#define rfbEncodingQualityLevel4 0xFFFFFFE4 >+#define rfbEncodingQualityLevel5 0xFFFFFFE5 >+#define rfbEncodingQualityLevel6 0xFFFFFFE6 >+#define rfbEncodingQualityLevel7 0xFFFFFFE7 >+#define rfbEncodingQualityLevel8 0xFFFFFFE8 >+#define rfbEncodingQualityLevel9 0xFFFFFFE9 >+ >+ >+/***************************************************************************** >+ * >+ * Server -> client message definitions >+ * >+ *****************************************************************************/ >+ >+ >+/*----------------------------------------------------------------------------- >+ * FramebufferUpdate - a block of rectangles to be copied to the framebuffer. >+ * >+ * This message consists of a header giving the number of rectangles of pixel >+ * data followed by the rectangles themselves. The header is padded so that >+ * together with the type byte it is an exact multiple of 4 bytes (to help >+ * with alignment of 32-bit pixels): >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbFramebufferUpdate */ >+ CARD8 pad; >+ CARD16 nRects; >+ /* followed by nRects rectangles */ >+} rfbFramebufferUpdateMsg; >+ >+#define sz_rfbFramebufferUpdateMsg 4 >+ >+/* >+ * Each rectangle of pixel data consists of a header describing the position >+ * and size of the rectangle and a type word describing the encoding of the >+ * pixel data, followed finally by the pixel data. Note that if the client has >+ * not sent a SetEncodings message then it will only receive raw pixel data. >+ * Also note again that this structure is a multiple of 4 bytes. >+ */ >+ >+typedef struct { >+ rfbRectangle r; >+ CARD32 encoding; /* one of the encoding types rfbEncoding... */ >+} rfbFramebufferUpdateRectHeader; >+ >+#define sz_rfbFramebufferUpdateRectHeader (sz_rfbRectangle + 4) >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * Raw Encoding. Pixels are sent in top-to-bottom scanline order, >+ * left-to-right within a scanline with no padding in between. >+ */ >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * CopyRect Encoding. The pixels are specified simply by the x and y position >+ * of the source rectangle. >+ */ >+ >+typedef struct { >+ CARD16 srcX; >+ CARD16 srcY; >+} rfbCopyRect; >+ >+#define sz_rfbCopyRect 4 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * RRE - Rise-and-Run-length Encoding. We have an rfbRREHeader structure >+ * giving the number of subrectangles following. Finally the data follows in >+ * the form [<bgpixel><subrect><subrect>...] where each <subrect> is >+ * [<pixel><rfbRectangle>]. >+ */ >+ >+typedef struct { >+ CARD32 nSubrects; >+} rfbRREHeader; >+ >+#define sz_rfbRREHeader 4 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * CoRRE - Compact RRE Encoding. We have an rfbRREHeader structure giving >+ * the number of subrectangles following. Finally the data follows in the form >+ * [<bgpixel><subrect><subrect>...] where each <subrect> is >+ * [<pixel><rfbCoRRERectangle>]. This means that >+ * the whole rectangle must be at most 255x255 pixels. >+ */ >+ >+typedef struct { >+ CARD8 x; >+ CARD8 y; >+ CARD8 w; >+ CARD8 h; >+} rfbCoRRERectangle; >+ >+#define sz_rfbCoRRERectangle 4 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * Hextile Encoding. The rectangle is divided up into "tiles" of 16x16 pixels, >+ * starting at the top left going in left-to-right, top-to-bottom order. If >+ * the width of the rectangle is not an exact multiple of 16 then the width of >+ * the last tile in each row will be correspondingly smaller. Similarly if the >+ * height is not an exact multiple of 16 then the height of each tile in the >+ * final row will also be smaller. Each tile begins with a "subencoding" type >+ * byte, which is a mask made up of a number of bits. If the Raw bit is set >+ * then the other bits are irrelevant; w*h pixel values follow (where w and h >+ * are the width and height of the tile). Otherwise the tile is encoded in a >+ * similar way to RRE, except that the position and size of each subrectangle >+ * can be specified in just two bytes. The other bits in the mask are as >+ * follows: >+ * >+ * BackgroundSpecified - if set, a pixel value follows which specifies >+ * the background colour for this tile. The first non-raw tile in a >+ * rectangle must have this bit set. If this bit isn't set then the >+ * background is the same as the last tile. >+ * >+ * ForegroundSpecified - if set, a pixel value follows which specifies >+ * the foreground colour to be used for all subrectangles in this tile. >+ * If this bit is set then the SubrectsColoured bit must be zero. >+ * >+ * AnySubrects - if set, a single byte follows giving the number of >+ * subrectangles following. If not set, there are no subrectangles (i.e. >+ * the whole tile is just solid background colour). >+ * >+ * SubrectsColoured - if set then each subrectangle is preceded by a pixel >+ * value giving the colour of that subrectangle. If not set, all >+ * subrectangles are the same colour, the foreground colour; if the >+ * ForegroundSpecified bit wasn't set then the foreground is the same as >+ * the last tile. >+ * >+ * The position and size of each subrectangle is specified in two bytes. The >+ * Pack macros below can be used to generate the two bytes from x, y, w, h, >+ * and the Extract macros can be used to extract the x, y, w, h values from >+ * the two bytes. >+ */ >+ >+#define rfbHextileRaw (1 << 0) >+#define rfbHextileBackgroundSpecified (1 << 1) >+#define rfbHextileForegroundSpecified (1 << 2) >+#define rfbHextileAnySubrects (1 << 3) >+#define rfbHextileSubrectsColoured (1 << 4) >+ >+#define rfbHextilePackXY(x,y) (((x) << 4) | (y)) >+#define rfbHextilePackWH(w,h) ((((w)-1) << 4) | ((h)-1)) >+#define rfbHextileExtractX(byte) ((byte) >> 4) >+#define rfbHextileExtractY(byte) ((byte) & 0xf) >+#define rfbHextileExtractW(byte) (((byte) >> 4) + 1) >+#define rfbHextileExtractH(byte) (((byte) & 0xf) + 1) >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * zlib - zlib compressed Encoding. We have an rfbZlibHeader structure >+ * giving the number of bytes following. Finally the data follows is >+ * zlib compressed version of the raw pixel data as negotiated. >+ */ >+ >+typedef struct { >+ CARD32 nBytes; >+} rfbZlibHeader; >+ >+#define sz_rfbZlibHeader 4 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * Tight Encoding. >+ * >+ *-- The first byte of each Tight-encoded rectangle is a "compression control >+ * byte". Its format is as follows (bit 0 is the least significant one): >+ * >+ * bit 0: if 1, then compression stream 0 should be reset; >+ * bit 1: if 1, then compression stream 1 should be reset; >+ * bit 2: if 1, then compression stream 2 should be reset; >+ * bit 3: if 1, then compression stream 3 should be reset; >+ * bits 7-4: if 1000 (0x08), then the compression type is "fill", >+ * if 1001 (0x09), then the compression type is "jpeg", >+ * if 0xxx, then the compression type is "basic", >+ * values greater than 1001 are not valid. >+ * >+ * If the compression type is "basic", then bits 6..4 of the >+ * compression control byte (those xxx in 0xxx) specify the following: >+ * >+ * bits 5-4: decimal representation is the index of a particular zlib >+ * stream which should be used for decompressing the data; >+ * bit 6: if 1, then a "filter id" byte is following this byte. >+ * >+ *-- The data that follows after the compression control byte described >+ * above depends on the compression type ("fill", "jpeg" or "basic"). >+ * >+ *-- If the compression type is "fill", then the only pixel value follows, in >+ * client pixel format (see NOTE 1). This value applies to all pixels of the >+ * rectangle. >+ * >+ *-- If the compression type is "jpeg", the following data stream looks like >+ * this: >+ * >+ * 1..3 bytes: data size (N) in compact representation; >+ * N bytes: JPEG image. >+ * >+ * Data size is compactly represented in one, two or three bytes, according >+ * to the following scheme: >+ * >+ * 0xxxxxxx (for values 0..127) >+ * 1xxxxxxx 0yyyyyyy (for values 128..16383) >+ * 1xxxxxxx 1yyyyyyy zzzzzzzz (for values 16384..4194303) >+ * >+ * Here each character denotes one bit, xxxxxxx are the least significant 7 >+ * bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the >+ * most significant 8 bits (bits 14-21). For example, decimal value 10000 >+ * should be represented as two bytes: binary 10010000 01001110, or >+ * hexadecimal 90 4E. >+ * >+ *-- If the compression type is "basic" and bit 6 of the compression control >+ * byte was set to 1, then the next (second) byte specifies "filter id" which >+ * tells the decoder what filter type was used by the encoder to pre-process >+ * pixel data before the compression. The "filter id" byte can be one of the >+ * following: >+ * >+ * 0: no filter ("copy" filter); >+ * 1: "palette" filter; >+ * 2: "gradient" filter. >+ * >+ *-- If bit 6 of the compression control byte is set to 0 (no "filter id" >+ * byte), or if the filter id is 0, then raw pixel values in the client >+ * format (see NOTE 1) will be compressed. See below details on the >+ * compression. >+ * >+ *-- The "gradient" filter pre-processes pixel data with a simple algorithm >+ * which converts each color component to a difference between a "predicted" >+ * intensity and the actual intensity. Such a technique does not affect >+ * uncompressed data size, but helps to compress photo-like images better. >+ * Pseudo-code for converting intensities to differences is the following: >+ * >+ * P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1]; >+ * if (P[i,j] < 0) then P[i,j] := 0; >+ * if (P[i,j] > MAX) then P[i,j] := MAX; >+ * D[i,j] := V[i,j] - P[i,j]; >+ * >+ * Here V[i,j] is the intensity of a color component for a pixel at >+ * coordinates (i,j). MAX is the maximum value of intensity for a color >+ * component. >+ * >+ *-- The "palette" filter converts true-color pixel data to indexed colors >+ * and a palette which can consist of 2..256 colors. If the number of colors >+ * is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to >+ * encode one pixel. 1-bit encoding is performed such way that the most >+ * significant bits correspond to the leftmost pixels, and each raw of pixels >+ * is aligned to the byte boundary. When "palette" filter is used, the >+ * palette is sent before the pixel data. The palette begins with an unsigned >+ * byte which value is the number of colors in the palette minus 1 (i.e. 1 >+ * means 2 colors, 255 means 256 colors in the palette). Then follows the >+ * palette itself which consist of pixel values in client pixel format (see >+ * NOTE 1). >+ * >+ *-- The pixel data is compressed using the zlib library. But if the data >+ * size after applying the filter but before the compression is less then 12, >+ * then the data is sent as is, uncompressed. Four separate zlib streams >+ * (0..3) can be used and the decoder should read the actual stream id from >+ * the compression control byte (see NOTE 2). >+ * >+ * If the compression is not used, then the pixel data is sent as is, >+ * otherwise the data stream looks like this: >+ * >+ * 1..3 bytes: data size (N) in compact representation; >+ * N bytes: zlib-compressed data. >+ * >+ * Data size is compactly represented in one, two or three bytes, just like >+ * in the "jpeg" compression method (see above). >+ * >+ *-- NOTE 1. If the color depth is 24, and all three color components are >+ * 8-bit wide, then one pixel in Tight encoding is always represented by >+ * three bytes, where the first byte is red component, the second byte is >+ * green component, and the third byte is blue component of the pixel color >+ * value. This applies to colors in palettes as well. >+ * >+ *-- NOTE 2. The decoder must reset compression streams' states before >+ * decoding the rectangle, if some of bits 0,1,2,3 in the compression control >+ * byte are set to 1. Note that the decoder must reset zlib streams even if >+ * the compression type is "fill" or "jpeg". >+ * >+ *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only >+ * when bits-per-pixel value is either 16 or 32, not 8. >+ * >+ *-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048 >+ * pixels. If a rectangle is wider, it must be split into several rectangles >+ * and each one should be encoded separately. >+ * >+ */ >+ >+#define rfbTightExplicitFilter 0x04 >+#define rfbTightFill 0x08 >+#define rfbTightJpeg 0x09 >+#define rfbTightMaxSubencoding 0x09 >+ >+/* Filters to improve compression efficiency */ >+#define rfbTightFilterCopy 0x00 >+#define rfbTightFilterPalette 0x01 >+#define rfbTightFilterGradient 0x02 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * XCursor encoding. This is a special encoding used to transmit X-style >+ * cursor shapes from server to clients. Note that for this encoding, >+ * coordinates in rfbFramebufferUpdateRectHeader structure hold hotspot >+ * position (r.x, r.y) and cursor size (r.w, r.h). If (w * h != 0), two RGB >+ * samples are sent after header in the rfbXCursorColors structure. They >+ * denote foreground and background colors of the cursor. If a client >+ * supports only black-and-white cursors, it should ignore these colors and >+ * assume that foreground is black and background is white. Next, two bitmaps >+ * (1 bits per pixel) follow: first one with actual data (value 0 denotes >+ * background color, value 1 denotes foreground color), second one with >+ * transparency data (bits with zero value mean that these pixels are >+ * transparent). Both bitmaps represent cursor data in a byte stream, from >+ * left to right, from top to bottom, and each row is byte-aligned. Most >+ * significant bits correspond to leftmost pixels. The number of bytes in >+ * each row can be calculated as ((w + 7) / 8). If (w * h == 0), cursor >+ * should be hidden (or default local cursor should be set by the client). >+ */ >+ >+typedef struct { >+ CARD8 foreRed; >+ CARD8 foreGreen; >+ CARD8 foreBlue; >+ CARD8 backRed; >+ CARD8 backGreen; >+ CARD8 backBlue; >+} rfbXCursorColors; >+ >+#define sz_rfbXCursorColors 6 >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * RichCursor encoding. This is a special encoding used to transmit cursor >+ * shapes from server to clients. It is similar to the XCursor encoding but >+ * uses client pixel format instead of two RGB colors to represent cursor >+ * image. For this encoding, coordinates in rfbFramebufferUpdateRectHeader >+ * structure hold hotspot position (r.x, r.y) and cursor size (r.w, r.h). >+ * After header, two pixmaps follow: first one with cursor image in current >+ * client pixel format (like in raw encoding), second with transparency data >+ * (1 bit per pixel, exactly the same format as used for transparency bitmap >+ * in the XCursor encoding). If (w * h == 0), cursor should be hidden (or >+ * default local cursor should be set by the client). >+ */ >+ >+ >+/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >+ * SoftCursor encoding. This encoding is used to transmit image and position >+ * of the remote cursor. It has two sub-messages: SetImage is used to upload >+ * one of 16 images, and Move selects the image and sets the position of the >+ * cursor. >+ * Each SoftCursor message starts with a CARD8. If it is in the 0-15 range >+ * it specifies the number of the cursor image and is followed by the >+ * rfbSoftCursorMove message. If the given cursor has not been set yet the >+ * message will be ignored. If the first CARD8 is in the 128-143 range it >+ * specifies the cursor that will be set in the following >+ * rfbSoftCursorSetImage message. To hide the cursor send a SetImage >+ * message with width and height 0 and imageLength 0. >+ * SetImage transmits the hotspot coordinates in the x/y fields of the >+ * rfbFramebufferUpdateRectHeader, width and height of the image are in the >+ * header's width and height fields. >+ * Move transmits the pointer coordinates in the w/h fields of the >+ * header, x/y are always 0. >+ */ >+ >+typedef struct { >+ CARD8 imageIndex; >+ CARD8 buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */ >+} rfbSoftCursorMove; >+ >+typedef struct { >+ CARD8 imageIndex; >+ CARD8 padding; >+ CARD16 imageLength; >+ /* >+ * Followed by an image of the cursor in the client's image format >+ * with the following RLE mask compression. It begins with CARD8 that >+ * specifies the number of mask'ed pixels that will be NOT transmitted. >+ * Then follows a CARD8 that specified by the number of unmask'd pixels >+ * that will be transmitted next. Then a CARD8 with the number of mask'd >+ * pixels and so on. >+ */ >+} rfbSoftCursorSetImage; >+ >+typedef union { >+ CARD8 type; >+ rfbSoftCursorMove move; >+ rfbSoftCursorSetImage setImage; >+} rfbSoftCursorMsg; >+ >+#define rfbSoftCursorMaxImages 16 >+#define rfbSoftCursorSetIconOffset 128 >+ >+/*----------------------------------------------------------------------------- >+ * SetColourMapEntries - these messages are only sent if the pixel >+ * format uses a "colour map" (i.e. trueColour false) and the client has not >+ * fixed the entire colour map using FixColourMapEntries. In addition they >+ * will only start being sent after the client has sent its first >+ * FramebufferUpdateRequest. So if the client always tells the server to use >+ * trueColour then it never needs to process this type of message. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbSetColourMapEntries */ >+ CARD8 pad; >+ CARD16 firstColour; >+ CARD16 nColours; >+ >+ /* Followed by nColours * 3 * CARD16 >+ r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ >+ >+} rfbSetColourMapEntriesMsg; >+ >+#define sz_rfbSetColourMapEntriesMsg 6 >+ >+ >+ >+/*----------------------------------------------------------------------------- >+ * Bell - ring a bell on the client if it has one. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbBell */ >+} rfbBellMsg; >+ >+#define sz_rfbBellMsg 1 >+ >+ >+ >+/*----------------------------------------------------------------------------- >+ * ServerCutText - the server has new text in its cut buffer. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbServerCutText */ >+ CARD8 pad1; >+ CARD16 pad2; >+ CARD32 length; >+ /* followed by char text[length] */ >+} rfbServerCutTextMsg; >+ >+#define sz_rfbServerCutTextMsg 8 >+ >+ >+/*----------------------------------------------------------------------------- >+ * Union of all server->client messages. >+ */ >+ >+typedef union { >+ CARD8 type; >+ rfbFramebufferUpdateMsg fu; >+ rfbSetColourMapEntriesMsg scme; >+ rfbBellMsg b; >+ rfbServerCutTextMsg sct; >+} rfbServerToClientMsg; >+ >+ >+ >+/***************************************************************************** >+ * >+ * Message definitions (client -> server) >+ * >+ *****************************************************************************/ >+ >+ >+/*----------------------------------------------------------------------------- >+ * SetPixelFormat - tell the RFB server the format in which the client wants >+ * pixels sent. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbSetPixelFormat */ >+ CARD8 pad1; >+ CARD16 pad2; >+ rfbPixelFormat format; >+} rfbSetPixelFormatMsg; >+ >+#define sz_rfbSetPixelFormatMsg (sz_rfbPixelFormat + 4) >+ >+ >+/*----------------------------------------------------------------------------- >+ * FixColourMapEntries - when the pixel format uses a "colour map", fix >+ * read-only colour map entries. >+ * >+ * ***************** NOT CURRENTLY SUPPORTED ***************** >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbFixColourMapEntries */ >+ CARD8 pad; >+ CARD16 firstColour; >+ CARD16 nColours; >+ >+ /* Followed by nColours * 3 * CARD16 >+ r1, g1, b1, r2, g2, b2, r3, g3, b3, ..., rn, bn, gn */ >+ >+} rfbFixColourMapEntriesMsg; >+ >+#define sz_rfbFixColourMapEntriesMsg 6 >+ >+ >+/*----------------------------------------------------------------------------- >+ * SetEncodings - tell the RFB server which encoding types we accept. Put them >+ * in order of preference, if we have any. We may always receive raw >+ * encoding, even if we don't specify it here. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbSetEncodings */ >+ CARD8 pad; >+ CARD16 nEncodings; >+ /* followed by nEncodings * CARD32 encoding types */ >+} rfbSetEncodingsMsg; >+ >+#define sz_rfbSetEncodingsMsg 4 >+ >+ >+/*----------------------------------------------------------------------------- >+ * FramebufferUpdateRequest - request for a framebuffer update. If incremental >+ * is true then the client just wants the changes since the last update. If >+ * false then it wants the whole of the specified rectangle. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbFramebufferUpdateRequest */ >+ CARD8 incremental; >+ CARD16 x; >+ CARD16 y; >+ CARD16 w; >+ CARD16 h; >+} rfbFramebufferUpdateRequestMsg; >+ >+#define sz_rfbFramebufferUpdateRequestMsg 10 >+ >+ >+/*----------------------------------------------------------------------------- >+ * KeyEvent - key press or release >+ * >+ * Keys are specified using the "keysym" values defined by the X Window System. >+ * For most ordinary keys, the keysym is the same as the corresponding ASCII >+ * value. Other common keys are: >+ * >+ * BackSpace 0xff08 >+ * Tab 0xff09 >+ * Return or Enter 0xff0d >+ * Escape 0xff1b >+ * Insert 0xff63 >+ * Delete 0xffff >+ * Home 0xff50 >+ * End 0xff57 >+ * Page Up 0xff55 >+ * Page Down 0xff56 >+ * Left 0xff51 >+ * Up 0xff52 >+ * Right 0xff53 >+ * Down 0xff54 >+ * F1 0xffbe >+ * F2 0xffbf >+ * ... ... >+ * F12 0xffc9 >+ * Shift 0xffe1 >+ * Control 0xffe3 >+ * Meta 0xffe7 >+ * Alt 0xffe9 >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbKeyEvent */ >+ CARD8 down; /* true if down (press), false if up */ >+ CARD16 pad; >+ CARD32 key; /* key is specified as an X keysym */ >+} rfbKeyEventMsg; >+ >+#define sz_rfbKeyEventMsg 8 >+ >+ >+/*----------------------------------------------------------------------------- >+ * PointerEvent - mouse/pen move and/or button press. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbPointerEvent */ >+ CARD8 buttonMask; /* bits 0-7 are buttons 1-8, 0=up, 1=down */ >+ CARD16 x; >+ CARD16 y; >+} rfbPointerEventMsg; >+ >+#define rfbButton1Mask 1 >+#define rfbButton2Mask 2 >+#define rfbButton3Mask 4 >+ >+#define sz_rfbPointerEventMsg 6 >+ >+ >+ >+/*----------------------------------------------------------------------------- >+ * ClientCutText - the client has new text in its cut buffer. >+ */ >+ >+typedef struct { >+ CARD8 type; /* always rfbClientCutText */ >+ CARD8 pad1; >+ CARD16 pad2; >+ CARD32 length; >+ /* followed by char text[length] */ >+} rfbClientCutTextMsg; >+ >+#define sz_rfbClientCutTextMsg 8 >+ >+ >+ >+/*----------------------------------------------------------------------------- >+ * Union of all client->server messages. >+ */ >+ >+typedef union { >+ CARD8 type; >+ rfbSetPixelFormatMsg spf; >+ rfbFixColourMapEntriesMsg fcme; >+ rfbSetEncodingsMsg se; >+ rfbFramebufferUpdateRequestMsg fur; >+ rfbKeyEventMsg ke; >+ rfbPointerEventMsg pe; >+ rfbClientCutTextMsg cct; >+} rfbClientToServerMsg; >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/scaling.cpp tdenetwork-trinity-14.1.0/krdc/vnc/scaling.cpp >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/scaling.cpp 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/scaling.cpp 1970-01-01 03:00:00.000000000 +0300 >@@ -1,331 +0,0 @@ >-/**************************************************************************** >-** >-** Copyright (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net> >-** >-** This file is part of TDE. >-** >-** This program is free software; you can redistribute it and/or modify >-** it under the terms of the GNU General Public License as published by >-** the Free Software Foundation; either version 2 of the License, or >-** (at your option) any later version. >-** >-** This program is distributed in the hope that it will be useful, >-** but WITHOUT ANY WARRANTY; without even the implied warranty of >-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >-** GNU General Public License for more details. >-** >-** You should have received a copy of the GNU General Public License >-** along with this program; see the file COPYING. If not, write to >-** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, >-** Boston, MA 02110-1301, USA. >-** >-****************************************************************************/ >- >-#include <tqimage.h> >- >-/*! >- >- Smooth scaling function with ability to limit scaled region >- The selection rectangle is given in terms of destination coordinates >- It leaves areas outside of the selection rectangle undefined... >- >- Function code originally taken from qimage.cpp pnmscale () and modified >- to only scale a section of the source >- >- This function uses code based on pnmscale.c by Jef Poskanzer. >- >- pnmscale.c - read a portable anymap and scale it >- >- \legalese >- >- Copyright (C) 1989, 1991 by Jef Poskanzer. >- >- Permission to use, copy, modify, and distribute this software and >- its documentation for any purpose and without fee is hereby >- granted, provided that the above copyright notice appear in all >- copies and that both that copyright notice and this permission >- notice appear in supporting documentation. This software is >- provided "as is" without express or implied warranty. >- >-*/ >- >-void pnmscale_fractional(const TQImage& src, TQImage& dst, int x, int y, int w, int h) >-{ >- TQRgb* xelrow = 0; >- TQRgb* tempxelrow = 0; >- TQRgb* xP; >- TQRgb* nxP; >- int rows, cols, rowsread, newrows, newcols; >- int row, col, needtoreadrow; >- const uchar maxval = 255; >- double xscale, yscale; >- long sxscale, syscale; >- long fracrowtofill, fracrowleft; >- long* as; >- long* rs; >- long* gs; >- long* bs; >- int rowswritten = 0; >- int colswritten = 0; >- >- cols = src.width(); >- rows = src.height(); >- newcols = dst.width(); >- newrows = dst.height(); >- >- long SCALE; >- long HALFSCALE; >- >- if (cols > 4096) >- { >- SCALE = 4096; >- HALFSCALE = 2048; >- } >- else >- { >- int fac = 4096; >- >- while (cols * fac > 4096) >- { >- fac /= 2; >- } >- >- SCALE = fac * cols; >- HALFSCALE = fac * cols / 2; >- } >- >- xscale = (double) newcols / (double) cols; >- yscale = (double) newrows / (double) rows; >- >- sxscale = (long)(xscale * SCALE); >- syscale = (long)(yscale * SCALE); >- >- if ( newrows != rows ) /* shortcut Y scaling if possible */ >- tempxelrow = new TQRgb[cols]; >- >- if ( src.hasAlphaBuffer() ) { >- dst.setAlphaBuffer(TRUE); >- as = new long[cols]; >- for ( col = 0; col < cols; ++col ) >- as[col] = HALFSCALE; >- } else { >- as = 0; >- } >- rs = new long[cols]; >- gs = new long[cols]; >- bs = new long[cols]; >- rowsread = 0; >- fracrowleft = syscale; >- needtoreadrow = 1; >- for ( col = 0; col < cols; ++col ) >- rs[col] = gs[col] = bs[col] = HALFSCALE; >- fracrowtofill = SCALE; >- >- for ( row = 0; row < newrows; ++row ) { >- /* First scale Y from xelrow into tempxelrow. */ >- if ( newrows == rows ) { >- /* shortcut Y scaling if possible */ >- tempxelrow = xelrow = (TQRgb*)src.scanLine(rowsread++); >- } else { >- while ( fracrowleft < fracrowtofill ) { >- if ( needtoreadrow && rowsread < rows ) >- xelrow = (TQRgb*)src.scanLine(rowsread++); >- for ( col = 0, xP = xelrow; col < cols; ++col, ++xP ) { >-if ((rowswritten >= y) && (rowswritten <= (y + h))) { >- if (as) { >- as[col] += fracrowleft * tqAlpha( *xP ); >- rs[col] += fracrowleft * tqRed( *xP ) * tqAlpha( *xP ) / 255; >- gs[col] += fracrowleft * tqGreen( *xP ) * tqAlpha( *xP ) / 255; >- bs[col] += fracrowleft * tqBlue( *xP ) * tqAlpha( *xP ) / 255; >- } else { >- rs[col] += fracrowleft * tqRed( *xP ); >- gs[col] += fracrowleft * tqGreen( *xP ); >- bs[col] += fracrowleft * tqBlue( *xP ); >- } >-} >- } >- fracrowtofill -= fracrowleft; >- fracrowleft = syscale; >- needtoreadrow = 1; >- } >- /* Now fracrowleft is >= fracrowtofill, so we can produce a row. */ >- if ( needtoreadrow && rowsread < rows ) { >- xelrow = (TQRgb*)src.scanLine(rowsread++); >- needtoreadrow = 0; >- } >- long a=0; >- for ( col = 0, xP = xelrow, nxP = tempxelrow, colswritten = 0; >- col < cols; ++col, ++xP, ++nxP, ++colswritten ) >- { >-if ((rowswritten >= y) && (rowswritten <= (y + h))) { >- long r, g, b; >- >- if ( as ) { >- r = rs[col] + fracrowtofill * tqRed( *xP ) * tqAlpha( *xP ) / 255; >- g = gs[col] + fracrowtofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255; >- b = bs[col] + fracrowtofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255; >- a = as[col] + fracrowtofill * tqAlpha( *xP ); >- if ( a ) { >- r = r * 255 / a * SCALE; >- g = g * 255 / a * SCALE; >- b = b * 255 / a * SCALE; >- } >- } else { >- r = rs[col] + fracrowtofill * tqRed( *xP ); >- g = gs[col] + fracrowtofill * tqGreen( *xP ); >- b = bs[col] + fracrowtofill * tqBlue( *xP ); >- } >- r /= SCALE; >- if ( r > maxval ) r = maxval; >- g /= SCALE; >- if ( g > maxval ) g = maxval; >- b /= SCALE; >- if ( b > maxval ) b = maxval; >- if ( as ) { >- a /= SCALE; >- if ( a > maxval ) a = maxval; >- *nxP = tqRgba( (int)r, (int)g, (int)b, (int)a ); >- as[col] = HALFSCALE; >- } else { >- *nxP = tqRgb( (int)r, (int)g, (int)b ); >- } >- rs[col] = gs[col] = bs[col] = HALFSCALE; >-} >- } >- fracrowleft -= fracrowtofill; >- if ( fracrowleft == 0 ) { >- fracrowleft = syscale; >- needtoreadrow = 1; >- } >- fracrowtofill = SCALE; >- } >- >- /* Now scale X from tempxelrow into dst and write it out. */ >- if ( newcols == cols ) { >- /* shortcut X scaling if possible */ >- memcpy(dst.scanLine(rowswritten++), tempxelrow, newcols*4); >- } else { >- long a, r, g, b; >- long fraccoltofill, fraccolleft = 0; >- int needcol; >- >- nxP = (TQRgb*)dst.scanLine(rowswritten++); >- colswritten = 0; >- fraccoltofill = SCALE; >- a = r = g = b = HALFSCALE; >- needcol = 0; >- for ( col = 0, xP = tempxelrow; col < cols; ++col, ++xP ) { >- fraccolleft = sxscale; >- while ( fraccolleft >= fraccoltofill ) { >- if ( needcol ) { >- ++nxP; >- ++colswritten; >- a = r = g = b = HALFSCALE; >- } >-if ((colswritten >= x) && (colswritten <= (x + w)) && (rowswritten >= y) && (rowswritten <= (y + h))) { >- if ( as ) { >- r += fraccoltofill * tqRed( *xP ) * tqAlpha( *xP ) / 255; >- g += fraccoltofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255; >- b += fraccoltofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255; >- a += fraccoltofill * tqAlpha( *xP ); >- if ( a ) { >- r = r * 255 / a * SCALE; >- g = g * 255 / a * SCALE; >- b = b * 255 / a * SCALE; >- } >- } else { >- r += fraccoltofill * tqRed( *xP ); >- g += fraccoltofill * tqGreen( *xP ); >- b += fraccoltofill * tqBlue( *xP ); >- } >- r /= SCALE; >- if ( r > maxval ) r = maxval; >- g /= SCALE; >- if ( g > maxval ) g = maxval; >- b /= SCALE; >- if ( b > maxval ) b = maxval; >- if (as) { >- a /= SCALE; >- if ( a > maxval ) a = maxval; >- *nxP = tqRgba( (int)r, (int)g, (int)b, (int)a ); >- } else { >- *nxP = tqRgb( (int)r, (int)g, (int)b ); >- } >-} >- fraccolleft -= fraccoltofill; >- fraccoltofill = SCALE; >- needcol = 1; >- } >- if ( fraccolleft > 0 ) { >- if ( needcol ) { >- ++nxP; >- ++colswritten; >- a = r = g = b = HALFSCALE; >- needcol = 0; >- } >-if ((rowswritten >= y) && (rowswritten <= (y + h))) { >- if (as) { >- a += fraccolleft * tqAlpha( *xP ); >- r += fraccolleft * tqRed( *xP ) * tqAlpha( *xP ) / 255; >- g += fraccolleft * tqGreen( *xP ) * tqAlpha( *xP ) / 255; >- b += fraccolleft * tqBlue( *xP ) * tqAlpha( *xP ) / 255; >- } else { >- r += fraccolleft * tqRed( *xP ); >- g += fraccolleft * tqGreen( *xP ); >- b += fraccolleft * tqBlue( *xP ); >- } >-} >- fraccoltofill -= fraccolleft; >- } >- } >- if ( fraccoltofill > 0 ) { >- --xP; >-if ((rowswritten >= y) && (rowswritten <= (y + h))) { >- if (as) { >- a += fraccolleft * tqAlpha( *xP ); >- r += fraccoltofill * tqRed( *xP ) * tqAlpha( *xP ) / 255; >- g += fraccoltofill * tqGreen( *xP ) * tqAlpha( *xP ) / 255; >- b += fraccoltofill * tqBlue( *xP ) * tqAlpha( *xP ) / 255; >- if ( a ) { >- r = r * 255 / a * SCALE; >- g = g * 255 / a * SCALE; >- b = b * 255 / a * SCALE; >- } >- } else { >- r += fraccoltofill * tqRed( *xP ); >- g += fraccoltofill * tqGreen( *xP ); >- b += fraccoltofill * tqBlue( *xP ); >- } >-} >- } >- if ( ! needcol ) { >-if ((rowswritten >= y) && (rowswritten <= (y + h))) { >- r /= SCALE; >- if ( r > maxval ) r = maxval; >- g /= SCALE; >- if ( g > maxval ) g = maxval; >- b /= SCALE; >- if ( b > maxval ) b = maxval; >- if (as) { >- a /= SCALE; >- if ( a > maxval ) a = maxval; >- *nxP = tqRgba( (int)r, (int)g, (int)b, (int)a ); >- } else { >- *nxP = tqRgb( (int)r, (int)g, (int)b ); >- } >-} >- } >- } >- } >- >- if ( newrows != rows && tempxelrow )// Robust, tempxelrow might be 0 1 day >- delete [] tempxelrow; >- if ( as ) // Avoid purify complaint >- delete [] as; >- if ( rs ) // Robust, rs might be 0 one day >- delete [] rs; >- if ( gs ) // Robust, gs might be 0 one day >- delete [] gs; >- if ( bs ) // Robust, bs might be 0 one day >- delete [] bs; >-} >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/sockets.c tdenetwork-trinity-14.1.0/krdc/vnc/sockets.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/sockets.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/sockets.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,325 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ * >+ * 03-05-2002 tim@tjansen.de: removed Xt event processing for krdc >+ */ >+ >+/* >+ * sockets.c - functions to deal with sockets. >+ */ >+ >+#include <unistd.h> >+#include <sys/socket.h> >+#include <errno.h> >+#include <netinet/in.h> >+#include <netinet/tcp.h> >+#include <arpa/inet.h> >+#include <netdb.h> >+#include <fcntl.h> >+#include <assert.h> >+#include "vncviewer.h" >+ >+void PrintInHex(char *buf, int len); >+ >+Bool errorMessageOnReadFailure = True; >+ >+#define BUF_SIZE 8192 >+static char buf[BUF_SIZE]; >+static char *bufoutptr = buf; >+static unsigned int buffered = 0; >+ >+/* Wait duration of select in seconds */ >+#define SELECT_PERIOD 3 >+ >+ >+/* >+ * ReadFromRFBServer is called whenever we want to read some data from the RFB >+ * server. >+ */ >+Bool >+ReadFromRFBServer(char *out, unsigned int n) >+{ >+ fd_set fds; >+ int e; >+ struct timeval tx; >+ >+ if (isQuitFlagSet()) >+ return False; >+ >+ if (n <= buffered) { >+ memcpy(out, bufoutptr, n); >+ bufoutptr += n; >+ buffered -= n; >+ return True; >+ } >+ >+ memcpy(out, bufoutptr, buffered); >+ >+ out += buffered; >+ n -= buffered; >+ >+ bufoutptr = buf; >+ buffered = 0; >+ >+ if (n <= BUF_SIZE) { >+ >+ while (buffered < n) { >+ int i; >+ if (isQuitFlagSet()) >+ return False; >+ i = read(rfbsock, buf + buffered, BUF_SIZE - buffered); >+ >+ if (i <= 0) { >+ if (i < 0) { >+ if (errno == EWOULDBLOCK || errno == EAGAIN) { >+ FD_ZERO(&fds); >+ FD_SET(rfbsock,&fds); >+ >+ tx.tv_sec = SELECT_PERIOD; >+ tx.tv_usec = 0; >+ if ((e=select(rfbsock+1, &fds, NULL, &fds, &tx)) < 0) { >+ perror("krdc: select read"); >+ return False; >+ } >+ i = 0; >+ } else { >+ perror("krdc: read"); >+ return False; >+ } >+ } else { >+ fprintf(stderr,"VNC server closed connection\n"); >+ return False; >+ } >+ } >+ buffered += i; >+ } >+ >+ memcpy(out, bufoutptr, n); >+ bufoutptr += n; >+ buffered -= n; >+ return isQuitFlagSet() ? False : True; >+ >+ } else { >+ >+ while (n > 0) { >+ int i; >+ if (isQuitFlagSet()) >+ return False; >+ i = read(rfbsock, out, n); >+ if (i <= 0) { >+ if (i < 0) { >+ if (errno == EWOULDBLOCK || errno == EAGAIN) { >+ FD_ZERO(&fds); >+ FD_SET(rfbsock,&fds); >+ >+ tx.tv_sec = SELECT_PERIOD; >+ tx.tv_usec = 0; >+ if ((e=select(rfbsock+1, &fds, NULL, &fds, &tx)) < 0) { >+ perror("krdc: select"); >+ return False; >+ } >+ i = 0; >+ } else { >+ perror("krdc: read"); >+ return False; >+ } >+ } else { >+ fprintf(stderr,"VNC server closed connection\n"); >+ return False; >+ } >+ } >+ out += i; >+ n -= i; >+ } >+ >+ return isQuitFlagSet() ? False : True; >+ } >+} >+ >+ >+/* >+ * Write an exact number of bytes, and don't return until you've sent them. >+ * Note: this should only be called by the WriterThread >+ */ >+ >+Bool >+WriteExact(int sock, const char *_buf, int n) >+{ >+ fd_set fds; >+ int i = 0; >+ int j; >+ int e; >+ struct timeval tx; >+ >+ while (i < n) { >+ if (isQuitFlagSet()) >+ return False; >+ j = write(sock, _buf + i, (n - i)); >+ if (j <= 0) { >+ if (j < 0) { >+ if (errno == EWOULDBLOCK || errno == EAGAIN) { >+ FD_ZERO(&fds); >+ FD_SET(rfbsock,&fds); >+ >+ tx.tv_sec = SELECT_PERIOD; >+ tx.tv_usec = 0; >+ if ((e=select(rfbsock+1, NULL, &fds, NULL, &tx)) < 0) { >+ perror("krdc: select write"); >+ return False; >+ } >+ j = 0; >+ } else { >+ perror("krdc: write"); >+ return False; >+ } >+ } else { >+ fprintf(stderr,"write failed\n"); >+ return False; >+ } >+ } >+ i += j; >+ } >+ return True; >+} >+ >+ >+/* >+ * ConnectToTcpAddr connects to the given TCP port. >+ */ >+ >+int >+ConnectToTcpAddr(unsigned int host, int port) >+{ >+ int sock; >+ struct sockaddr_in addr; >+ int one = 1; >+ >+ addr.sin_family = AF_INET; >+ addr.sin_port = htons(port); >+ addr.sin_addr.s_addr = host; >+ >+ sock = socket(AF_INET, SOCK_STREAM, 0); >+ if (sock < 0) { >+ perror("krdc: ConnectToTcpAddr: socket"); >+ return -(int)INIT_CONNECTION_FAILED; >+ } >+ >+ if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { >+ perror("krdc: ConnectToTcpAddr: connect"); >+ close(sock); >+ return -(int)INIT_NO_SERVER; >+ } >+ >+ if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, >+ (char *)&one, sizeof(one)) < 0) { >+ perror("krdc: ConnectToTcpAddr: setsockopt"); >+ close(sock); >+ return -(int)INIT_CONNECTION_FAILED; >+ } >+ >+ if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) { >+ perror(": AcceptTcpConnection: fcntl"); >+ close(sock); >+ return -(int)INIT_CONNECTION_FAILED; >+ } >+ >+ return sock; >+} >+ >+ >+/* >+ * StringToIPAddr - convert a host string to an IP address. >+ */ >+ >+Bool >+StringToIPAddr(const char *str, unsigned int *addr) >+{ >+ struct hostent *hp; >+ >+ if (strcmp(str,"") == 0) { >+ *addr = 0; /* local */ >+ return True; >+ } >+ >+ *addr = inet_addr(str); >+ >+ if (*addr != -1) >+ return True; >+ >+ hp = gethostbyname(str); >+ >+ if (hp) { >+ *addr = *(unsigned int *)hp->h_addr; >+ return True; >+ } >+ >+ return False; >+} >+ >+ >+/* >+ * Print out the contents of a packet for debugging. >+ */ >+ >+void >+PrintInHex(char *_buf, int len) >+{ >+ int i, j; >+ char c, str[17]; >+ >+ str[16] = 0; >+ >+ fprintf(stderr,"ReadExact: "); >+ >+ for (i = 0; i < len; i++) >+ { >+ if ((i % 16 == 0) && (i != 0)) { >+ fprintf(stderr," "); >+ } >+ c = _buf[i]; >+ str[i % 16] = (((c > 31) && (c < 127)) ? c : '.'); >+ fprintf(stderr,"%02x ",(unsigned char)c); >+ if ((i % 4) == 3) >+ fprintf(stderr," "); >+ if ((i % 16) == 15) >+ { >+ fprintf(stderr,"%s\n",str); >+ } >+ } >+ if ((i % 16) != 0) >+ { >+ for (j = i % 16; j < 16; j++) >+ { >+ fprintf(stderr," "); >+ if ((j % 4) == 3) fprintf(stderr," "); >+ } >+ str[i % 16] = 0; >+ fprintf(stderr,"%s\n",str); >+ } >+ >+ fflush(stderr); >+} >+ >+void freeSocketsResources() { >+ close(rfbsock); >+ >+ errorMessageOnReadFailure = True; >+ bufoutptr = buf; >+ buffered = 0; >+} >+ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.cpp tdenetwork-trinity-14.1.0/krdc/vnc/threads.cpp >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.cpp 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/threads.cpp 2022-09-18 07:50:27.000000000 +0300 >@@ -2,8 +2,7 @@ > threads.cpp - threads > ------------------- > begin : Thu May 09 17:01:44 CET 2002 >- copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net> >- (C) 2002 by Tim Jansen >+ copyright : (C) 2002 by Tim Jansen > email : tim@tjansen.de > ***************************************************************************/ > >@@ -25,360 +24,369 @@ > #include "threads.h" > > #include <tqcstring.h> >-#include <tqpainter.h> > >-#include <math.h> >+// Maximum idle time for writer thread in ms. When it timeouts, it will request >+// another incremental update. Must be smaller than the timeout of the server >+// (krfb's is 20s). >+static const int MAXIMUM_WAIT_PERIOD = 8000; > >-extern void pnmscale_fractional(const TQImage& src, TQImage& dst, int x, int y, int w, int h); >+// time to postpone incremental updates that have not been requested explicitly >+static const int POSTPONED_INCRRQ_WAIT_PERIOD = 110; > >-int getPassword(char * &passwd); >+static const int MOUSEPRESS_QUEUE_SIZE = 5; >+static const int MOUSEMOVE_QUEUE_SIZE = 3; >+static const int KEY_QUEUE_SIZE = 8192; > >-extern rfbBool newclient(rfbClient *cl) >-{ >- int width = cl->width, height = cl->height, depth = cl->format.bitsPerPixel; >- int size = width * height * (depth / 8); >- uint8_t *buf = new uint8_t[size]; >- memset(buf, '\0', size); >- cl->frameBuffer = buf; >- cl->format.bitsPerPixel = 32; >- cl->format.redShift = 16; >- cl->format.greenShift = 8; >- cl->format.blueShift = 0; >- cl->format.redMax = 0xff; >- cl->format.greenMax = 0xff; >- cl->format.blueMax = 0xff; >- >- SetFormatAndEncodings(cl); >- >- return true; >-} >- >-extern void updatefb(rfbClient* cl, int x, int y, int w, int h) >-{ >-// kdDebug(5011) << "updated client: x: " << x << ", y: " << y << ", w: " << w << ", h: " << h << endl; >- >- int width = cl->width, height = cl->height; >- >- TQImage img(cl->frameBuffer, width, height, 32, NULL, 256, TQImage::IgnoreEndian); >- >- if (img.isNull()) >- kdDebug(5011) << "image not loaded" << endl; >- >- >- ControllerThreadObject *t = (ControllerThreadObject*)rfbClientGetClientData(cl, 0); >- >- t->setImage(img); >- t->queueDrawRegion(x, y, w, h); >-} >- >-extern char *passwd(rfbClient *cl) >-{ >- Q_UNUSED(cl) > >- kdDebug(5011) << "password request" << endl; >- >- char *passwd; >- if (getPassword(passwd)) { >- return passwd; >- } >- else { >- return NULL; >- } >-} >- >-extern void authresults(rfbClient *cl, uint32_t authResult) >-{ >- kdDebug(5011) << "authentication result: " << authResult << endl; >- >- ControllerThreadObject *t = (ControllerThreadObject*)rfbClientGetClientData(cl, 0); >- >- t->authenticationResults(authResult); >-} >- >-extern void networkstat(rfbClient *cl, uint32_t statuscode) >-{ >- kdDebug(5011) << "network status: " << statuscode << endl; >- >- ControllerThreadObject *t = (ControllerThreadObject*)rfbClientGetClientData(cl, 0); >- >- t->networkStatus(statuscode); >-} >- >-extern void output(const char *format, ...) >-{ >- va_list args; >- va_start(args, format); >- >- TQString message; >- message.vsprintf(format, args); >- >- va_end(args); >- >- kdDebug(5011) << message.local8Bit(); >- >- if (message.contains("Could not open")) { >- kdDebug(5011) << "Server not found!" << endl; >- } >- >- if (message.contains("VNC authentication succeeded")) { >- kdDebug(5011) << "Password OK" << endl; >- } >-} >- >-ControllerThreadObject::ControllerThreadObject(KVncView *v, volatile bool &quitFlag) : >- cl(0L), >+ControllerThread::ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag) : > m_view(v), > m_status(REMOTE_VIEW_CONNECTING), >+ m_wthread(wt), > m_quitFlag(quitFlag), >- m_scaling(false), >- m_scalingWidth(-1), >- m_scalingHeight(-1), >- m_resizeEntireFrame(false) >+ m_desktopInitialized(false) > { >- TQMutexLocker locker(&mutex); >- >- cl = rfbGetClient(8, 3, 4); > } > >-ControllerThreadObject::~ControllerThreadObject() { >- TQMutexLocker locker(&mutex); >- >- rfbClientCleanup(cl); >-} >- >-void ControllerThreadObject::changeStatus(RemoteViewStatus s) { >+void ControllerThread::changeStatus(RemoteViewStatus s) { > m_status = s; > TQApplication::postEvent(m_view, new StatusChangeEvent(s)); > } > >-void ControllerThreadObject::sendFatalError(ErrorCode s) { >+void ControllerThread::sendFatalError(ErrorCode s) { > m_quitFlag = true; > TQApplication::postEvent(m_view, new FatalErrorEvent(s)); >+ m_wthread.kick(); > } > >-void ControllerThreadObject::queueDrawRegion(int x, int y, int w, int h) { >- if (m_scaling) { >- // Rescale desktop >+/* >+ * Calls this from the X11 thread >+ */ >+void ControllerThread::desktopInit() { >+ SetVisualAndCmap(); >+ ToplevelInit(); >+ DesktopInit(m_view->winId()); >+ m_desktopInitialized = true; >+ m_waiter.wakeAll(); >+} >+ >+void ControllerThread::kick() { >+ m_waiter.wakeAll(); >+} >+ >+void ControllerThread::run() { >+ int fd; >+ fd = ConnectToRFBServer(m_view->host().latin1(), m_view->port()); >+ if (fd < 0) { >+ if (fd == -(int)INIT_NO_SERVER) >+ sendFatalError(ERROR_NO_SERVER); >+ else if (fd == -(int)INIT_NAME_RESOLUTION_FAILURE) >+ sendFatalError(ERROR_NAME); >+ else >+ sendFatalError(ERROR_CONNECTION); >+ return; >+ } >+ if (m_quitFlag) { >+ changeStatus(REMOTE_VIEW_DISCONNECTED); >+ return; >+ } >+ >+ changeStatus(REMOTE_VIEW_AUTHENTICATING); > >- int new_x; >- int new_y; >- int new_w; >- int new_h; >+ enum InitStatus s = InitialiseRFBConnection(); >+ if (s != INIT_OK) { >+ if (s == INIT_CONNECTION_FAILED) >+ sendFatalError(ERROR_IO); >+ else if (s == INIT_SERVER_BLOCKED) >+ sendFatalError(ERROR_SERVER_BLOCKED); >+ else if (s == INIT_PROTOCOL_FAILURE) >+ sendFatalError(ERROR_PROTOCOL); >+ else if (s == INIT_AUTHENTICATION_FAILED) >+ sendFatalError(ERROR_AUTHENTICATION); >+ else if (s == INIT_ABORTED) >+ changeStatus(REMOTE_VIEW_DISCONNECTED); >+ else >+ sendFatalError(ERROR_INTERNAL); >+ return; >+ } > >- mutex.lock(); >+ TQApplication::postEvent(m_view, >+ new ScreenResizeEvent(si.framebufferWidth, >+ si.framebufferHeight)); >+ m_wthread.queueUpdateRequest(TQRegion(TQRect(0,0,si.framebufferWidth, >+ si.framebufferHeight))); >+ >+ TQApplication::postEvent(m_view, new DesktopInitEvent()); >+ while ((!m_quitFlag) && (!m_desktopInitialized)) >+ m_waiter.wait(1000); > >- if (m_resizeEntireFrame) { >- m_scaledImage.create(m_scalingWidth, m_scalingHeight, 32); >+ if (m_quitFlag) { >+ changeStatus(REMOTE_VIEW_DISCONNECTED); >+ return; >+ } > >- new_x = 0; >- new_y = 0; >- new_w = m_scalingWidth; >- new_h = m_scalingHeight; >+ changeStatus(REMOTE_VIEW_PREPARING); > >- TQImage scaledBlock = m_image.smoothScale(new_w, new_h); >- bitBlt(&m_scaledImage, new_x, new_y, &scaledBlock, 0, 0, new_w, new_h); >+ if (!SetFormatAndEncodings()) { >+ sendFatalError(ERROR_INTERNAL); >+ return; >+ } > >- m_resizeEntireFrame = false; >- } >- else { >- // Extend redraw boundaries to avoid pixelation artifacts due to rounding errors >- x = x - round((2.0 * m_image.width()) / m_scalingWidth); >- y = y - round((2.0 * m_image.height()) / m_scalingHeight); >- w = w + round((4.0 * m_image.width()) / m_scalingWidth); >- h = h + round((4.0 * m_image.height()) / m_scalingHeight); >+ changeStatus(REMOTE_VIEW_CONNECTED); > >- if (x < 0) { >- x = 0; >- } >- if (y < 0) { >- y = 0; >- } >- if (w > m_image.width()) { >- w = m_image.width(); >- } >- if (h > m_image.height()) { >- h = m_image.height(); >- } >+ m_wthread.start(); > >- new_x = round((x * m_scalingWidth) / m_image.width()); >- new_y = round((y * m_scalingHeight) / m_image.height()); >- new_w = round((w * m_scalingWidth) / m_image.width()); >- new_h = round((h * m_scalingHeight) / m_image.height()); >- >- TQImage scaledBlock(m_scalingWidth, m_scalingHeight, 32); >- pnmscale_fractional(m_image, scaledBlock, new_x, new_y, new_w, new_h); >- bitBlt(&m_scaledImage, new_x, new_y, &scaledBlock, new_x, new_y, new_w, new_h); >+ while (!m_quitFlag) { >+ if ((!HandleRFBServerMessage()) && (!m_quitFlag)) { >+ sendFatalError(ERROR_IO); >+ return; > } >+ } > >- mutex.unlock(); >+ m_quitFlag = true; >+ changeStatus(REMOTE_VIEW_DISCONNECTED); >+ m_wthread.kick(); >+} > >- DrawScreenRegion(new_x, new_y, new_w, new_h); >- } >- else { >- DrawScreenRegion(x, y, w, h); >- } >+enum RemoteViewStatus ControllerThread::status() { >+ return m_status; > } > >-void ControllerThreadObject::setImage(const TQImage &img) { >- TQMutexLocker locker(&mutex); > >- m_image = img; >-} > >-const TQImage ControllerThreadObject::image(int x, int y, int w, int h) { >- TQMutexLocker locker(&mutex); > >- if (m_scaling) { >- return m_scaledImage.copy(x, y, w, h); >- } >- else { >- return m_image.copy(x, y, w, h); >- } >-} > >-void ControllerThreadObject::setScaling(int w, int h) { >- bool scale; >+static WriterThread *writerThread; >+void queueIncrementalUpdateRequest() { >+ writerThread->queueIncrementalUpdateRequest(); >+} > >- if (w <= 0) { >- scale = false; >- } >- else { >- scale = true; >- } >+void announceIncrementalUpdateRequest() { >+ writerThread->announceIncrementalUpdateRequest(); >+} > >- if ((m_scalingWidth != w) || (m_scalingHeight = h) || (m_scaling != scale)) { >- m_resizeEntireFrame = true; >- } > >- m_scaling = scale; >- m_scalingWidth = w; >- m_scalingHeight = h; >-} >- >-void ControllerThreadObject::run() { >- mutex.lock(); >- >- rfbClientLog = output; >- rfbClientErr = output; >- cl->MallocFrameBuffer = newclient; >- cl->canHandleNewFBSize = true; >- cl->GetPassword = passwd; >- cl->AuthenticationResults = authresults; >- cl->NetworkStatus = networkstat; >- cl->GotFrameBufferUpdate = updatefb; >- rfbClientSetClientData(cl, 0, this); >- >- // make a copy of the host string... >- char *host = (char*) malloc(m_view->host().length()); >- strcpy(host, m_view->host().ascii()); >- >- cl->serverHost = host; >- >- int port = m_view->port(); >- if(port >= 0 && port < 100) // the user most likely used the short form (e.g. :1) >- port += 5900; >- cl->serverPort = port; >+WriterThread::WriterThread(KVncView *v, volatile bool &quitFlag) : >+ m_quitFlag(quitFlag), >+ m_view(v), >+ m_lastIncrUpdatePostponed(false), >+ m_incrementalUpdateRQ(false), >+ m_incrementalUpdateAnnounced(false), >+ m_mouseEventNum(0), >+ m_keyEventNum(0), >+ m_clientCut(TQString()) >+{ >+ writerThread = this; >+ m_lastIncrUpdate.start(); >+} > >- mutex.unlock(); >+bool WriterThread::sendIncrementalUpdateRequest() { >+ m_lastIncrUpdate.restart(); >+ return SendIncrementalFramebufferUpdateRequest(); >+} >+ >+bool WriterThread::sendUpdateRequest(const TQRegion &region) { >+ TQMemArray<TQRect> r = region.rects(); >+ for (unsigned int i = 0; i < r.size(); i++) >+ if (!SendFramebufferUpdateRequest(r[i].x(), >+ r[i].y(), >+ r[i].width(), >+ r[i].height(), False)) >+ return false; >+ return true; >+} > >- if(!rfbInitClient(cl, 0, 0)) { >- sendFatalError(ERROR_INTERNAL); >- // Terminate thread >- TQThread::exit(); >- return; >+bool WriterThread::sendInputEvents(const TQValueList<InputEvent> &events) { >+ TQValueList<InputEvent>::const_iterator it = events.begin(); >+ while (it != events.end()) { >+ if ((*it).type == KeyEventType) { >+ if (!SendKeyEvent((*it).e.k.k, (*it).e.k.down ? True : False)) >+ return false; >+ } >+ else >+ if (!SendPointerEvent((*it).e.m.x, (*it).e.m.y, (*it).e.m.buttons)) >+ return false; >+ it++; > } >+ return true; >+} > >- TQApplication::postEvent(m_view, >- new ScreenResizeEvent(cl->width, >- cl->height)); >+void WriterThread::queueIncrementalUpdateRequest() { >+ m_lock.lock(); >+ m_incrementalUpdateRQ = true; >+ m_waiter.wakeAll(); >+ m_lock.unlock(); >+} >+ >+void WriterThread::announceIncrementalUpdateRequest() { >+ m_lock.lock(); >+ m_incrementalUpdateAnnounced = true; >+ m_lock.unlock(); >+} > >- changeStatus(REMOTE_VIEW_CONNECTED); >- >- while (!m_quitFlag) { >- int i = WaitForMessage(cl, 500); >- if (i < 0) { >- m_quitFlag = true; >- changeStatus(REMOTE_VIEW_DISCONNECTED); > >- // Terminate thread >- TQThread::exit(); >+void WriterThread::queueUpdateRequest(const TQRegion &r) { >+ m_lock.lock(); >+ m_updateRegionRQ += r; >+ m_waiter.wakeAll(); >+ m_lock.unlock(); >+} >+ >+void WriterThread::queueMouseEvent(int x, int y, int buttonMask) { >+ InputEvent e; >+ e.type = MouseEventType; >+ e.e.m.x = x; >+ e.e.m.y = y; >+ e.e.m.buttons = buttonMask; >+ >+ m_lock.lock(); >+ if (m_mouseEventNum > 0) { >+ if ((e.e.m.x == m_lastMouseEvent.x) && >+ (e.e.m.y == m_lastMouseEvent.y) && >+ (e.e.m.buttons == m_lastMouseEvent.buttons)) { >+ m_lock.unlock(); > return; > } >- if (i) { >- if(!HandleRFBServerMessage(cl)) { >- m_quitFlag = true; >- changeStatus(REMOTE_VIEW_DISCONNECTED); >- >- // Terminate thread >- TQThread::exit(); >- return; >- } >+ if (m_mouseEventNum >= MOUSEPRESS_QUEUE_SIZE) { >+ m_lock.unlock(); >+ return; >+ } >+ if ((m_lastMouseEvent.buttons == buttonMask) && >+ (m_mouseEventNum >= MOUSEMOVE_QUEUE_SIZE)) { >+ m_lock.unlock(); >+ return; > } > } > >- m_quitFlag = true; >- changeStatus(REMOTE_VIEW_DISCONNECTED); >- >- // Terminate thread >- TQThread::exit(); >-} >- >-void ControllerThreadObject::authenticationResults(int resultCode) { >- if (resultCode == rfbVncAuthOK) { >- changeStatus(REMOTE_VIEW_PREPARING); >- } >- else { >- sendFatalError(ERROR_AUTHENTICATION); >+ m_mouseEventNum++; >+ m_lastMouseEvent = e.e.m; > >- // Terminate thread >- TQThread::exit(); >+ m_inputEvents.push_back(e); >+ m_waiter.wakeAll(); >+ m_lock.unlock(); >+} >+ >+void WriterThread::queueKeyEvent(unsigned int k, bool down) { >+ InputEvent e; >+ e.type = KeyEventType; >+ e.e.k.k = k; >+ e.e.k.down = down; >+ >+ m_lock.lock(); >+ if (m_keyEventNum >= KEY_QUEUE_SIZE) { >+ m_lock.unlock(); >+ return; > } >-} > >-void ControllerThreadObject::networkStatus(int statusCode) { >- if (statusCode == rfbNetworkConnectionSuccess) { >- // Stage 1 OK... >- changeStatus(REMOTE_VIEW_AUTHENTICATING); >- } >- else if (statusCode == rfbNetworkRFBConnectionSuccess) { >- // Stage 2 OK! >- } >- else { >- if (statusCode == rfbNetworkConnectionClosed) { >- sendFatalError(ERROR_CONNECTION); >- } >- else if (statusCode == rfbNetworkConnectionFailed) { >- sendFatalError(ERROR_CONNECTION); >- } >- else if (statusCode == rfbNetworkNameResolutionFailed) { >- sendFatalError(ERROR_NAME); >- } >- else if (statusCode == rfbNetworkRFBServerNotValid) { >- sendFatalError(ERROR_IO); >+ m_keyEventNum++; >+ m_inputEvents.push_back(e); >+ m_waiter.wakeAll(); >+ m_lock.unlock(); >+} >+ >+void WriterThread::queueClientCut(const TQString &text) { >+ m_lock.lock(); >+ >+ m_clientCut = text; >+ >+ m_waiter.wakeAll(); >+ m_lock.unlock(); >+} >+ >+void WriterThread::kick() { >+ m_waiter.wakeAll(); >+} >+ >+void WriterThread::run() { >+ bool incrementalUpdateRQ = false; >+ bool incrementalUpdateAnnounced = false; >+ TQRegion updateRegionRQ; >+ TQValueList<InputEvent> inputEvents; >+ TQString clientCut; >+ >+ while (!m_quitFlag) { >+ m_lock.lock(); >+ incrementalUpdateRQ = m_incrementalUpdateRQ; >+ incrementalUpdateAnnounced = m_incrementalUpdateAnnounced; >+ updateRegionRQ = m_updateRegionRQ; >+ inputEvents = m_inputEvents; >+ clientCut = m_clientCut; >+ >+ if ((!incrementalUpdateRQ) && >+ (updateRegionRQ.isNull()) && >+ (inputEvents.size() == 0) && >+ (clientCut.isNull())) { >+ if (!m_waiter.wait(&m_lock, >+ m_lastIncrUpdatePostponed ? >+ POSTPONED_INCRRQ_WAIT_PERIOD : MAXIMUM_WAIT_PERIOD)) >+ m_incrementalUpdateRQ = true; >+ m_lock.unlock(); > } >- else if (statusCode == rfbNetworkRFBProtocolFailure) { >- sendFatalError(ERROR_PROTOCOL); >+ else { >+ m_incrementalUpdateRQ = false; >+ m_incrementalUpdateAnnounced = false; >+ m_updateRegionRQ = TQRegion(); >+ m_inputEvents.clear(); >+ m_keyEventNum = 0; >+ m_mouseEventNum = 0; >+ m_clientCut = TQString(); >+ m_lock.unlock(); >+ >+ // always send incremental update, unless >+ // a) a framebuffer update is done ATM and will do the request later, or >+ // b) the last unrequested update has been done less than 0.1s ago >+ // >+ // if the update has not been done because of b, postpone it. >+ if (incrementalUpdateRQ || !incrementalUpdateAnnounced) { >+ bool sendUpdate; >+ if (incrementalUpdateRQ) { >+ sendUpdate = true; >+ m_lastIncrUpdatePostponed = false; >+ } >+ else { >+ if (m_lastIncrUpdate.elapsed() < 100) { >+ sendUpdate = false; >+ m_lastIncrUpdatePostponed = true; >+ } >+ else { >+ sendUpdate = true; >+ m_lastIncrUpdatePostponed = false; >+ } >+ } >+ >+ if (sendUpdate) >+ if (!sendIncrementalUpdateRequest()) { >+ sendFatalError(ERROR_IO); >+ break; >+ } >+ } >+ else >+ m_lastIncrUpdatePostponed = false; >+ >+ if (!updateRegionRQ.isNull()) >+ if (!sendUpdateRequest(updateRegionRQ)) { >+ sendFatalError(ERROR_IO); >+ break; >+ } >+ if (inputEvents.size() != 0) >+ if (!sendInputEvents(inputEvents)) { >+ sendFatalError(ERROR_IO); >+ break; >+ } >+ if (!clientCut.isNull()) { >+ TQCString cutTextUtf8(clientCut.utf8()); >+ if (!SendClientCutText(cutTextUtf8.data(), >+ (int)cutTextUtf8.length())) { >+ sendFatalError(ERROR_IO); >+ break; >+ } >+ } > } >- >- // Terminate thread >- TQThread::exit(); > } >+ m_quitFlag = true; > } > >-enum RemoteViewStatus ControllerThreadObject::status() { >- return m_status; >-} >- >-void ControllerThreadObject::queueMouseEvent(int x, int y, int buttonMask) { >- SendPointerEvent(cl, x, y, buttonMask); >-} >- >-void ControllerThreadObject::queueKeyEvent(unsigned int k, bool down) { >- SendKeyEvent(cl, k, down); >-} >- >-void ControllerThreadObject::queueClientCut(const TQString &text) { >- SendClientCutText(cl, (char*)text.ascii(), text.length()); >+void WriterThread::sendFatalError(ErrorCode s) { >+ m_quitFlag = true; >+ TQApplication::postEvent(m_view, new FatalErrorEvent(s)); > } > >-#include "threads.moc" >\ Наприкінці файла немає нового рядка >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.h tdenetwork-trinity-14.1.0/krdc/vnc/threads.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/threads.h 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/threads.h 2022-09-18 07:50:27.000000000 +0300 >@@ -2,8 +2,7 @@ > threads.h - threads for kvncview > ------------------- > begin : Thu May 09 16:01:42 CET 2002 >- copyright : (C) 2015 Timothy Pearson <kb9vqf@pearsoncomputing.net> >- (C) 2002 by Tim Jansen >+ copyright : (C) 2002 by Tim Jansen > email : tim@tjansen.de > ***************************************************************************/ > >@@ -27,15 +26,11 @@ > #include <tqevent.h> > #include <tqvaluelist.h> > #include <tqdatetime.h> >-#include <tqimage.h> > > #include <stdlib.h> > > #include "events.h" >- >-extern "C" { >-#include <rfb/rfbclient.h> >-} >+#include "vnctypes.h" > > class KVncView; > >@@ -62,51 +57,68 @@ > } e; > }; > >-class ControllerThreadObject : public TQObject { >- TQ_OBJECT >- >- public: >- ControllerThreadObject(KVncView *v, volatile bool &quitFlag); >- ~ControllerThreadObject(); >- >- enum RemoteViewStatus status(); > >- void setImage(const TQImage &img); >- const TQImage image(int x = 0, int y = 0, int w = 0, int h = 0); >- void authenticationResults(int resultCode); >- void networkStatus(int statusCode); >+class WriterThread : public TQThread { >+private: >+ TQMutex m_lock; >+ TQWaitCondition m_waiter; >+ volatile bool &m_quitFlag; >+ KVncView *m_view; >+ >+ TQTime m_lastIncrUpdate; // start()ed when a incr update is sent >+ bool m_lastIncrUpdatePostponed; >+ >+ // all things that can be send follow: >+ bool m_incrementalUpdateRQ; // for sending an incremental request >+ bool m_incrementalUpdateAnnounced; // set when a RQ will come soon >+ TQRegion m_updateRegionRQ; // for sending updates, null if it is done >+ TQValueList<InputEvent> m_inputEvents; // list of unsent input events >+ MouseEvent m_lastMouseEvent; >+ int m_mouseEventNum, m_keyEventNum; >+ TQString m_clientCut; > >- void setScaling(int w, int h); >- void queueDrawRegion(int x, int y, int w, int h); >+ void sendFatalError(ErrorCode s); > >- rfbClient *cl; >- >- public slots: >- void run(); >- >- public: >- void queueMouseEvent(int x, int y, int buttonMask); >- void queueKeyEvent(unsigned int k, bool down); >- void queueClientCut(const TQString &text); >- >- private: >- KVncView *m_view; >- TQImage m_image; >- TQImage m_scaledImage; >- TQMutex mutex; >- enum RemoteViewStatus m_status; >- volatile bool &m_quitFlag; >- >- bool m_scaling; >- int m_scalingWidth; >- int m_scalingHeight; >- bool m_resizeEntireFrame; >+public: >+ WriterThread(KVncView *v, volatile bool &quitFlag); > >- // all things that can be send follow: >- TQValueList<InputEvent> m_inputEvents; // list of unsent input events >+ void queueIncrementalUpdateRequest(); >+ void announceIncrementalUpdateRequest(); >+ void queueUpdateRequest(const TQRegion &r); >+ void queueMouseEvent(int x, int y, int buttonMask); >+ void queueKeyEvent(unsigned int k, bool down); >+ void queueClientCut(const TQString &text); >+ void kick(); > >- void changeStatus(RemoteViewStatus s); >- void sendFatalError(ErrorCode s); >+protected: >+ void run(); >+ bool sendIncrementalUpdateRequest(); >+ bool sendUpdateRequest(const TQRegion &r); >+ bool sendInputEvents(const TQValueList<InputEvent> &events); >+}; >+ >+ >+ >+class ControllerThread : public TQThread { >+private: >+ KVncView *m_view; >+ enum RemoteViewStatus m_status; >+ WriterThread &m_wthread; >+ volatile bool &m_quitFlag; >+ volatile bool m_desktopInitialized; >+ TQWaitCondition m_waiter; >+ >+ void changeStatus(RemoteViewStatus s); >+ void sendFatalError(ErrorCode s); >+ >+public: >+ ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag); >+ enum RemoteViewStatus status(); >+ void desktopInit(); >+ void kick(); >+ >+protected: >+ void run(); > }; > > >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/tight.c tdenetwork-trinity-14.1.0/krdc/vnc/tight.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/tight.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/tight.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,610 @@ >+/* >+ * Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * tight.c - handle ``tight'' encoding. >+ * >+ * This file shouldn't be compiled directly. It is included multiple >+ * times by rfbproto.c, each time with a different definition of the >+ * macro BPP. For each value of BPP, this file defines a function >+ * which handles a tight-encoded rectangle with BPP bits per pixel. >+ * >+ */ >+ >+#define TIGHT_MIN_TO_COMPRESS 12 >+ >+#define CARDBPP CONCAT2E(CARD,BPP) >+#define filterPtrBPP CONCAT2E(filterPtr,BPP) >+ >+#define HandleTightBPP CONCAT2E(HandleTight,BPP) >+#define InitFilterCopyBPP CONCAT2E(InitFilterCopy,BPP) >+#define InitFilterPaletteBPP CONCAT2E(InitFilterPalette,BPP) >+#define InitFilterGradientBPP CONCAT2E(InitFilterGradient,BPP) >+#define FilterCopyBPP CONCAT2E(FilterCopy,BPP) >+#define FilterPaletteBPP CONCAT2E(FilterPalette,BPP) >+#define FilterGradientBPP CONCAT2E(FilterGradient,BPP) >+#define FillRectangleBPP CONCAT2E(FillRectangle,BPP) >+ >+#if BPP != 8 >+#define DecompressJpegRectBPP CONCAT2E(DecompressJpegRect,BPP) >+#endif >+ >+#ifndef RGB_TO_PIXEL >+ >+#define RGB_TO_PIXEL(bpp,r,g,b) \ >+ (((CARD##bpp)(r) & myFormat.redMax) << myFormat.redShift | \ >+ ((CARD##bpp)(g) & myFormat.greenMax) << myFormat.greenShift | \ >+ ((CARD##bpp)(b) & myFormat.blueMax) << myFormat.blueShift) >+ >+#define RGB24_TO_PIXEL(bpp,r,g,b) \ >+ ((((CARD##bpp)(r) & 0xFF) * myFormat.redMax + 127) / 255 \ >+ << myFormat.redShift | \ >+ (((CARD##bpp)(g) & 0xFF) * myFormat.greenMax + 127) / 255 \ >+ << myFormat.greenShift | \ >+ (((CARD##bpp)(b) & 0xFF) * myFormat.blueMax + 127) / 255 \ >+ << myFormat.blueShift) >+ >+#define RGB24_TO_PIXEL32(r,g,b) \ >+ (((CARD32)(r) & 0xFF) << myFormat.redShift | \ >+ ((CARD32)(g) & 0xFF) << myFormat.greenShift | \ >+ ((CARD32)(b) & 0xFF) << myFormat.blueShift) >+ >+#endif >+ >+/* Type declarations */ >+ >+typedef void (*filterPtrBPP)(int, CARDBPP *); >+ >+/* Prototypes */ >+ >+static int InitFilterCopyBPP (int rw, int rh); >+static int InitFilterPaletteBPP (int rw, int rh); >+static int InitFilterGradientBPP (int rw, int rh); >+static void FilterCopyBPP (int numRows, CARDBPP *destBuffer); >+static void FilterPaletteBPP (int numRows, CARDBPP *destBuffer); >+static void FilterGradientBPP (int numRows, CARDBPP *destBuffer); >+ >+static Bool DecompressJpegRectBPP(int x, int y, int w, int h); >+ >+/* Definitions */ >+ >+static Bool >+HandleTightBPP (int rx, int ry, int rw, int rh) >+{ >+ CARDBPP fill_colour; >+ XGCValues gcv; >+ CARD8 comp_ctl; >+ CARD8 filter_id; >+ filterPtrBPP filterFn; >+ z_streamp zs; >+ char *buffer2; >+ int err, stream_id, compressedLen, bitsPixel; >+ int bufferSize, rowSize, numRows, portionLen, rowsProcessed, extraBytes; >+ CARDBPP *rawData; >+ >+ if (!ReadFromRFBServer((char *)&comp_ctl, 1)) >+ return False; >+ >+ /* Flush zlib streams if we are told by the server to do so. */ >+ for (stream_id = 0; stream_id < 4; stream_id++) { >+ if ((comp_ctl & 1) && zlibStreamActive[stream_id]) { >+ if (inflateEnd (&zlibStream[stream_id]) != Z_OK && >+ zlibStream[stream_id].msg != NULL) >+ fprintf(stderr, "inflateEnd: %s\n", zlibStream[stream_id].msg); >+ zlibStreamActive[stream_id] = False; >+ } >+ comp_ctl >>= 1; >+ } >+ >+ /* Handle solid rectangles. */ >+ if (comp_ctl == rfbTightFill) { >+#if BPP == 32 >+ if (myFormat.depth == 24 && myFormat.redMax == 0xFF && >+ myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) { >+ if (!ReadFromRFBServer(buffer, 3)) >+ return False; >+ fill_colour = RGB24_TO_PIXEL32(buffer[0], buffer[1], buffer[2]); >+ } else { >+ if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour))) >+ return False; >+ } >+#else >+ if (!ReadFromRFBServer((char*)&fill_colour, sizeof(fill_colour))) >+ return False; >+#endif >+ >+ LockFramebuffer(); >+ FillRectangleBPP(fill_colour, rx, ry, rw, rh); >+ UnlockFramebuffer(); >+ SyncScreenRegion(rx, ry, rw, rh); >+ return True; >+ } >+ >+#if BPP == 8 >+ if (comp_ctl == rfbTightJpeg) { >+ fprintf(stderr, "Tight encoding: JPEG is not supported in 8 bpp mode.\n"); >+ return False; >+ } >+#else >+ if (comp_ctl == rfbTightJpeg) { >+ return DecompressJpegRectBPP(rx, ry, rw, rh); >+ } >+#endif >+ >+ /* Quit on unsupported subencoding value. */ >+ if (comp_ctl > rfbTightMaxSubencoding) { >+ fprintf(stderr, "Tight encoding: bad subencoding value received.\n"); >+ return False; >+ } >+ >+ /* >+ * Here primary compression mode handling begins. >+ * Data was processed with optional filter + zlib compression. >+ */ >+ >+ /* First, we should identify a filter to use. */ >+ if ((comp_ctl & rfbTightExplicitFilter) != 0) { >+ if (!ReadFromRFBServer((char*)&filter_id, 1)) >+ return False; >+ >+ switch (filter_id) { >+ case rfbTightFilterCopy: >+ filterFn = FilterCopyBPP; >+ bitsPixel = InitFilterCopyBPP(rw, rh); >+ break; >+ case rfbTightFilterPalette: >+ filterFn = FilterPaletteBPP; >+ bitsPixel = InitFilterPaletteBPP(rw, rh); >+ break; >+ case rfbTightFilterGradient: >+ filterFn = FilterGradientBPP; >+ bitsPixel = InitFilterGradientBPP(rw, rh); >+ break; >+ default: >+ fprintf(stderr, "Tight encoding: unknown filter code received.\n"); >+ return False; >+ } >+ } else { >+ filterFn = FilterCopyBPP; >+ bitsPixel = InitFilterCopyBPP(rw, rh); >+ } >+ if (bitsPixel == 0) { >+ fprintf(stderr, "Tight encoding: error receiving palette.\n"); >+ return False; >+ } >+ >+ /* Determine if the data should be decompressed or just copied. */ >+ rowSize = (rw * bitsPixel + 7) / 8; >+ if (rh * rowSize < TIGHT_MIN_TO_COMPRESS) { >+ if (!ReadFromRFBServer((char*)buffer, rh * rowSize)) >+ return False; >+ >+ buffer2 = &buffer[TIGHT_MIN_TO_COMPRESS * 4]; >+ filterFn(rh, (CARDBPP *)buffer2); >+ CopyDataToScreen(buffer2, rx, ry, rw, rh); >+ >+ return True; >+ } >+ >+ /* Read the length (1..3 bytes) of compressed data following. */ >+ compressedLen = (int)ReadCompactLen(); >+ if (compressedLen <= 0) { >+ fprintf(stderr, "Incorrect data received from the server.\n"); >+ return False; >+ } >+ >+ /* Now let's initialize compression stream if needed. */ >+ stream_id = comp_ctl & 0x03; >+ zs = &zlibStream[stream_id]; >+ if (!zlibStreamActive[stream_id]) { >+ zs->zalloc = Z_NULL; >+ zs->zfree = Z_NULL; >+ zs->opaque = Z_NULL; >+ err = inflateInit(zs); >+ if (err != Z_OK) { >+ if (zs->msg != NULL) >+ fprintf(stderr, "InflateInit error: %s.\n", zs->msg); >+ return False; >+ } >+ zlibStreamActive[stream_id] = True; >+ } >+ >+ /* Read, decode and draw actual pixel data in a loop. */ >+ >+ bufferSize = BUFFER_SIZE * bitsPixel / (bitsPixel + BPP) & 0xFFFFFFFC; >+ buffer2 = &buffer[bufferSize]; >+ if (rowSize > bufferSize) { >+ /* Should be impossible when BUFFER_SIZE >= 16384 */ >+ fprintf(stderr, "Internal error: incorrect buffer size.\n"); >+ return False; >+ } >+ >+ rowsProcessed = 0; >+ extraBytes = 0; >+ >+ while (compressedLen > 0) { >+ if (compressedLen > ZLIB_BUFFER_SIZE) >+ portionLen = ZLIB_BUFFER_SIZE; >+ else >+ portionLen = compressedLen; >+ >+ if (!ReadFromRFBServer((char*)zlib_buffer, portionLen)) >+ return False; >+ >+ compressedLen -= portionLen; >+ >+ zs->next_in = (Bytef *)zlib_buffer; >+ zs->avail_in = portionLen; >+ >+ do { >+ zs->next_out = (Bytef *)&buffer[extraBytes]; >+ zs->avail_out = bufferSize - extraBytes; >+ >+ err = inflate(zs, Z_SYNC_FLUSH); >+ if (err == Z_BUF_ERROR) /* Input exhausted -- no problem. */ >+ break; >+ if (err != Z_OK && err != Z_STREAM_END) { >+ if (zs->msg != NULL) { >+ fprintf(stderr, "Inflate error: %s.\n", zs->msg); >+ } else { >+ fprintf(stderr, "Inflate error: %d.\n", err); >+ } >+ return False; >+ } >+ >+ numRows = (bufferSize - zs->avail_out) / rowSize; >+ >+ filterFn(numRows, (CARDBPP *)buffer2); >+ >+ extraBytes = bufferSize - zs->avail_out - numRows * rowSize; >+ if (extraBytes > 0) >+ memcpy(buffer, &buffer[numRows * rowSize], extraBytes); >+ >+ CopyDataToScreen(buffer2, rx, ry + rowsProcessed, rw, numRows); >+ rowsProcessed += numRows; >+ } >+ while (zs->avail_out == 0); >+ } >+ >+ if (rowsProcessed != rh) { >+ fprintf(stderr, "Incorrect number of scan lines after decompression.\n"); >+ return False; >+ } >+ >+ return True; >+} >+ >+/*---------------------------------------------------------------------------- >+ * >+ * Filter stuff. >+ * >+ */ >+ >+/* >+ The following variables are defined in rfbproto.c: >+ static Bool cutZeros; >+ static int rectWidth, rectColors; >+ static CARD8 tightPalette[256*4]; >+ static CARD8 tightPrevRow[2048*3*sizeof(CARD16)]; >+*/ >+ >+static int >+InitFilterCopyBPP (int rw, int rh) >+{ >+ rectWidth = rw; >+ >+#if BPP == 32 >+ if (myFormat.depth == 24 && myFormat.redMax == 0xFF && >+ myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) { >+ cutZeros = True; >+ return 24; >+ } else { >+ cutZeros = False; >+ } >+#endif >+ >+ return BPP; >+} >+ >+static void >+FilterCopyBPP (int numRows, CARDBPP *dst) >+{ >+ >+#if BPP == 32 >+ int x, y; >+ >+ if (cutZeros) { >+ for (y = 0; y < numRows; y++) { >+ for (x = 0; x < rectWidth; x++) { >+ dst[y*rectWidth+x] = >+ RGB24_TO_PIXEL32(buffer[(y*rectWidth+x)*3], >+ buffer[(y*rectWidth+x)*3+1], >+ buffer[(y*rectWidth+x)*3+2]); >+ } >+ } >+ return; >+ } >+#endif >+ >+ memcpy (dst, buffer, numRows * rectWidth * (BPP / 8)); >+} >+ >+static int >+InitFilterGradientBPP (int rw, int rh) >+{ >+ int bits; >+ >+ bits = InitFilterCopyBPP(rw, rh); >+ if (cutZeros) >+ memset(tightPrevRow, 0, rw * 3); >+ else >+ memset(tightPrevRow, 0, rw * 3 * sizeof(CARD16)); >+ >+ return bits; >+} >+ >+#if BPP == 32 >+ >+static void >+FilterGradient24 (int numRows, CARD32 *dst) >+{ >+ int x, y, c; >+ CARD8 thisRow[2048*3]; >+ CARD8 pix[3]; >+ int est[3]; >+ >+ for (y = 0; y < numRows; y++) { >+ >+ /* First pixel in a row */ >+ for (c = 0; c < 3; c++) { >+ pix[c] = tightPrevRow[c] + buffer[y*rectWidth*3+c]; >+ thisRow[c] = pix[c]; >+ } >+ dst[y*rectWidth] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]); >+ >+ /* Remaining pixels of a row */ >+ for (x = 1; x < rectWidth; x++) { >+ for (c = 0; c < 3; c++) { >+ est[c] = (int)tightPrevRow[x*3+c] + (int)pix[c] - >+ (int)tightPrevRow[(x-1)*3+c]; >+ if (est[c] > 0xFF) { >+ est[c] = 0xFF; >+ } else if (est[c] < 0x00) { >+ est[c] = 0x00; >+ } >+ pix[c] = (CARD8)est[c] + buffer[(y*rectWidth+x)*3+c]; >+ thisRow[x*3+c] = pix[c]; >+ } >+ dst[y*rectWidth+x] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]); >+ } >+ >+ memcpy(tightPrevRow, thisRow, rectWidth * 3); >+ } >+} >+ >+#endif >+ >+static void >+FilterGradientBPP (int numRows, CARDBPP *dst) >+{ >+ int x, y, c; >+ CARDBPP *src = (CARDBPP *)buffer; >+ CARD16 *thatRow = (CARD16 *)tightPrevRow; >+ CARD16 thisRow[2048*3]; >+ CARD16 pix[3]; >+ CARD16 max[3]; >+ int shift[3]; >+ int est[3]; >+ >+#if BPP == 32 >+ if (cutZeros) { >+ FilterGradient24(numRows, dst); >+ return; >+ } >+#endif >+ >+ max[0] = myFormat.redMax; >+ max[1] = myFormat.greenMax; >+ max[2] = myFormat.blueMax; >+ >+ shift[0] = myFormat.redShift; >+ shift[1] = myFormat.greenShift; >+ shift[2] = myFormat.blueShift; >+ >+ for (y = 0; y < numRows; y++) { >+ >+ /* First pixel in a row */ >+ for (c = 0; c < 3; c++) { >+ pix[c] = (CARD16)((src[y*rectWidth] >> shift[c]) + thatRow[c] & max[c]); >+ thisRow[c] = pix[c]; >+ } >+ dst[y*rectWidth] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]); >+ >+ /* Remaining pixels of a row */ >+ for (x = 1; x < rectWidth; x++) { >+ for (c = 0; c < 3; c++) { >+ est[c] = (int)thatRow[x*3+c] + (int)pix[c] - (int)thatRow[(x-1)*3+c]; >+ if (est[c] > (int)max[c]) { >+ est[c] = (int)max[c]; >+ } else if (est[c] < 0) { >+ est[c] = 0; >+ } >+ pix[c] = (CARD16)((src[y*rectWidth+x] >> shift[c]) + est[c] & max[c]); >+ thisRow[x*3+c] = pix[c]; >+ } >+ dst[y*rectWidth+x] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]); >+ } >+ memcpy(thatRow, thisRow, rectWidth * 3 * sizeof(CARD16)); >+ } >+} >+ >+static int >+InitFilterPaletteBPP (int rw, int rh) >+{ >+ int i; >+ CARD8 numColors; >+ CARDBPP *palette = (CARDBPP *)tightPalette; >+ >+ rectWidth = rw; >+ >+ if (!ReadFromRFBServer((char*)&numColors, 1)) >+ return 0; >+ >+ rectColors = (int)numColors; >+ if (++rectColors < 2) >+ return 0; >+ >+#if BPP == 32 >+ if (myFormat.depth == 24 && myFormat.redMax == 0xFF && >+ myFormat.greenMax == 0xFF && myFormat.blueMax == 0xFF) { >+ if (!ReadFromRFBServer((char*)&tightPalette, rectColors * 3)) >+ return 0; >+ for (i = rectColors - 1; i >= 0; i--) { >+ palette[i] = RGB24_TO_PIXEL32(tightPalette[i*3], >+ tightPalette[i*3+1], >+ tightPalette[i*3+2]); >+ } >+ return (rectColors == 2) ? 1 : 8; >+ } >+#endif >+ >+ if (!ReadFromRFBServer((char*)&tightPalette, rectColors * (BPP / 8))) >+ return 0; >+ >+ return (rectColors == 2) ? 1 : 8; >+} >+ >+static void >+FilterPaletteBPP (int numRows, CARDBPP *dst) >+{ >+ int x, y, b, w; >+ CARD8 *src = (CARD8 *)buffer; >+ CARDBPP *palette = (CARDBPP *)tightPalette; >+ >+ if (rectColors == 2) { >+ w = (rectWidth + 7) / 8; >+ for (y = 0; y < numRows; y++) { >+ for (x = 0; x < rectWidth / 8; x++) { >+ for (b = 7; b >= 0; b--) >+ dst[y*rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1]; >+ } >+ for (b = 7; b >= 8 - rectWidth % 8; b--) { >+ dst[y*rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1]; >+ } >+ } >+ } else { >+ for (y = 0; y < numRows; y++) >+ for (x = 0; x < rectWidth; x++) >+ dst[y*rectWidth+x] = palette[(int)src[y*rectWidth+x]]; >+ } >+} >+ >+#if BPP != 8 >+ >+/*---------------------------------------------------------------------------- >+ * >+ * JPEG decompression. >+ * >+ */ >+ >+/* >+ The following variables are defined in rfbproto.c: >+ static Bool jpegError; >+ static struct jpeg_source_mgr jpegSrcManager; >+ static JOCTET *jpegBufferPtr; >+ static size_t *jpegBufferLen; >+*/ >+ >+static Bool >+DecompressJpegRectBPP(int x, int y, int w, int h) >+{ >+ struct jpeg_decompress_struct cinfo; >+ struct jpeg_error_mgr jerr; >+ int compressedLen; >+ CARD8 *compressedData; >+ CARDBPP *pixelPtr; >+ JSAMPROW rowPointer[1]; >+ int dx, dy; >+ >+ compressedLen = (int)ReadCompactLen(); >+ if (compressedLen <= 0) { >+ fprintf(stderr, "Incorrect data received from the server.\n"); >+ return False; >+ } >+ >+ if (compressedLen > MAX_JPEG_SIZE) { >+ fprintf(stderr, "To large data announced by the server.\n"); >+ return False; >+ } >+ >+ compressedData = malloc(compressedLen); >+ if (compressedData == NULL) { >+ fprintf(stderr, "Memory allocation error.\n"); >+ return False; >+ } >+ >+ if (!ReadFromRFBServer((char*)compressedData, compressedLen)) { >+ free(compressedData); >+ return False; >+ } >+ >+ cinfo.err = jpeg_std_error(&jerr); >+ jpeg_create_decompress(&cinfo); >+ >+ JpegSetSrcManager(&cinfo, compressedData, compressedLen); >+ >+ jpeg_read_header(&cinfo, TRUE); >+ cinfo.out_color_space = JCS_RGB; >+ >+ jpeg_start_decompress(&cinfo); >+ if (cinfo.output_width != w || cinfo.output_height != h || >+ cinfo.output_components != 3) { >+ fprintf(stderr, "Tight Encoding: Wrong JPEG data received.\n"); >+ jpeg_destroy_decompress(&cinfo); >+ free(compressedData); >+ return False; >+ } >+ >+ rowPointer[0] = (JSAMPROW)buffer; >+ dy = 0; >+ while (cinfo.output_scanline < cinfo.output_height) { >+ jpeg_read_scanlines(&cinfo, rowPointer, 1); >+ if (jpegError) { >+ break; >+ } >+ pixelPtr = (CARDBPP *)&buffer[BUFFER_SIZE / 2]; >+ for (dx = 0; dx < w; dx++) { >+ *pixelPtr++ = >+ RGB24_TO_PIXEL(BPP, buffer[dx*3], buffer[dx*3+1], buffer[dx*3+2]); >+ } >+ CopyDataToScreen(&buffer[BUFFER_SIZE / 2], x, y + dy, w, 1); >+ dy++; >+ } >+ >+ if (!jpegError) >+ jpeg_finish_decompress(&cinfo); >+ >+ jpeg_destroy_decompress(&cinfo); >+ free(compressedData); >+ >+ return !jpegError; >+} >+ >+#endif >+ >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncauth.c tdenetwork-trinity-14.1.0/krdc/vnc/vncauth.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncauth.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/vncauth.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,161 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this program; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * vncauth.c - Functions for VNC password management and authentication. >+ */ >+ >+#include <stdio.h> >+#include <stdlib.h> >+#include <string.h> >+#include <sys/types.h> >+#include <sys/stat.h> >+#include <vncauth.h> >+#include <d3des.h> >+ >+ >+/* >+ * We use a fixed key to store passwords, since we assume that our local >+ * file system is secure but nonetheless don't want to store passwords >+ * as plaintext. >+ */ >+ >+unsigned char fixedkey[8] = {23,82,107,6,35,78,88,7}; >+ >+ >+/* >+ * Encrypt a password and store it in a file. Returns 0 if successful, >+ * 1 if the file could not be written. >+ */ >+ >+int >+vncEncryptAndStorePasswd(char *passwd, char *fname) >+{ >+ FILE *fp; >+ int i; >+ unsigned char encryptedPasswd[8]; >+ >+ if ((fp = fopen(fname,"w")) == NULL) return 1; >+ >+ chmod(fname, S_IRUSR|S_IWUSR); >+ >+ /* pad password with nulls */ >+ >+ for (i = 0; i < 8; i++) { >+ if (i < strlen(passwd)) { >+ encryptedPasswd[i] = passwd[i]; >+ } else { >+ encryptedPasswd[i] = 0; >+ } >+ } >+ >+ /* Do encryption in-place - this way we overwrite our copy of the plaintext >+ password */ >+ >+ deskey(fixedkey, EN0); >+ des(encryptedPasswd, encryptedPasswd); >+ >+ for (i = 0; i < 8; i++) { >+ putc(encryptedPasswd[i], fp); >+ } >+ >+ fclose(fp); >+ return 0; >+} >+ >+ >+/* >+ * Decrypt a password from a file. Returns a pointer to a newly allocated >+ * string containing the password or a null pointer if the password could >+ * not be retrieved for some reason. >+ */ >+ >+char * >+vncDecryptPasswdFromFile(char *fname) >+{ >+ FILE *fp; >+ int i, ch; >+ unsigned char *passwd = (unsigned char *)malloc(9); >+ >+ if ((fp = fopen(fname,"r")) == NULL) return NULL; >+ >+ for (i = 0; i < 8; i++) { >+ ch = getc(fp); >+ if (ch == EOF) { >+ fclose(fp); >+ return NULL; >+ } >+ passwd[i] = ch; >+ } >+ >+ fclose(fp); >+ >+ deskey(fixedkey, DE1); >+ des(passwd, passwd); >+ >+ passwd[8] = 0; >+ >+ return (char *)passwd; >+} >+ >+ >+/* >+ * Generate CHALLENGESIZE random bytes for use in challenge-response >+ * authentication. >+ */ >+ >+void >+vncRandomBytes(unsigned char *bytes) >+{ >+ int i; >+ unsigned int seed = (unsigned int) time(0); >+ >+ srandom(seed); >+ for (i = 0; i < CHALLENGESIZE; i++) { >+ bytes[i] = (unsigned char)(random() & 255); >+ } >+} >+ >+ >+/* >+ * Encrypt CHALLENGESIZE bytes in memory using a password. >+ */ >+ >+void >+vncEncryptBytes(unsigned char *bytes, char *passwd) >+{ >+ unsigned char key[8]; >+ int i; >+ >+ /* key is simply password padded with nulls */ >+ >+ for (i = 0; i < 8; i++) { >+ if (i < strlen(passwd)) { >+ key[i] = passwd[i]; >+ } else { >+ key[i] = 0; >+ } >+ } >+ >+ deskey(key, EN0); >+ >+ for (i = 0; i < CHALLENGESIZE; i += 8) { >+ des(bytes+i, bytes+i); >+ } >+} >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncauth.h tdenetwork-trinity-14.1.0/krdc/vnc/vncauth.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncauth.h 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/vncauth.h 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,30 @@ >+/* >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * vncauth.h - describes the functions provided by the vncauth library. >+ */ >+ >+#define MAXPWLEN 8 >+#define CHALLENGESIZE 16 >+ >+extern int vncEncryptAndStorePasswd(char *passwd, char *fname); >+extern char *vncDecryptPasswdFromFile(char *fname); >+extern void vncRandomBytes(unsigned char *bytes); >+extern void vncEncryptBytes(unsigned char *bytes, char *passwd); >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vnctypes.h tdenetwork-trinity-14.1.0/krdc/vnc/vnctypes.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vnctypes.h 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/vnctypes.h 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,73 @@ >+/* >+ * Copyright (C) 2002 Tim Jansen. All Rights Reserved. >+ * Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved. >+ * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+#ifndef VNCTYPES_H >+#define VNCTYPES_H >+ >+#if(defined __cplusplus) >+extern "C" >+{ >+#endif >+ >+#include <X11/Xmd.h> >+ >+ >+typedef struct { >+ int shareDesktop; /* bool */ >+ int viewOnly; /* bool */ >+ >+ const char* encodingsString; >+ >+ int useBGR233; /* bool */ >+ int nColours; >+ int useSharedColours; /* bool */ >+ int requestedDepth; >+ >+ int rawDelay; >+ int copyRectDelay; >+ >+ int debug; /* bool */ >+ >+ int compressLevel; >+ int qualityLevel; >+ int dotCursor; /* bool */ >+ >+} AppData; >+ >+ >+enum InitStatus { >+ INIT_OK = 0, >+ INIT_NAME_RESOLUTION_FAILURE = 1, >+ INIT_PROTOCOL_FAILURE = 2, >+ INIT_CONNECTION_FAILED = 3, >+ INIT_AUTHENTICATION_FAILED = 4, >+ INIT_NO_SERVER = 5, >+ INIT_SERVER_BLOCKED = 6, >+ INIT_ABORTED = 7 >+}; >+ >+ >+#if(defined __cplusplus) >+} >+#endif >+ >+#endif >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncviewer.h tdenetwork-trinity-14.1.0/krdc/vnc/vncviewer.h >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/vncviewer.h 2023-03-21 03:13:18.000000000 +0200 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/vncviewer.h 2022-09-18 07:50:27.000000000 +0300 >@@ -36,14 +36,28 @@ > #include <X11/keysym.h> > #include <X11/Xatom.h> > #include <X11/Xmu/StdSel.h> >+#include "vnctypes.h" > > #if(defined __cplusplus) > extern "C" > { > #endif > >-#include "rfb/rfbclient.h" >-#include "rfb/rfbproto.h" >+#include "rfbproto.h" >+ >+extern int endianTest; >+ >+#define Swap16IfLE(s) \ >+ (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s)) >+ >+#define Swap32IfLE(l) \ >+ (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \ >+ (((l) & 0x00ff0000) >> 8) | \ >+ (((l) & 0x0000ff00) << 8) | \ >+ (((l) & 0x000000ff) << 24)) : (l)) >+ >+#define MAX_ENCODINGS 20 >+ > > /** kvncview.cpp **/ > >@@ -64,6 +78,108 @@ > extern void newServerCut(char *bytes, int len); > extern void postMouseEvent(int x, int y, int buttonMask); > >+/** threads.cpp **/ >+ >+extern void queueIncrementalUpdateRequest(); >+extern void announceIncrementalUpdateRequest(); >+ >+/* colour.c */ >+ >+extern unsigned long BGR233ToPixel[]; >+ >+extern Colormap cmap; >+extern Visual *vis; >+extern unsigned int visdepth, visbpp; >+ >+extern void SetVisualAndCmap(void); >+ >+/* desktop.c */ >+ >+extern Widget form, viewport, desktop; >+extern GC gc; >+extern GC srcGC, dstGC; >+extern Dimension dpyWidth, dpyHeight; >+ >+extern void DesktopInit(Window win); >+extern void ToplevelInit(void); >+extern void SendRFBEvent(XEvent *event, String *params, Cardinal *num_params); >+extern void CopyDataToScreen(char *buf, int x, int y, int width, int height); >+extern void CopyDataFromScreen(char *buf, int x, int y, int width, int height); >+extern void FillRectangle8(CARD8, int x, int y, int width, int height); >+extern void FillRectangle16(CARD16, int x, int y, int width, int height); >+extern void FillRectangle32(CARD32, int x, int y, int width, int height); >+extern void CopyArea(int srcX, int srcY, int width, int height, int x, int y); >+extern void SyncScreenRegion(int x, int y, int width, int height); >+extern void SyncScreenRegionX11Thread(int x, int y, int width, int height); >+extern void drawCursor(void); >+extern void DrawCursorX11Thread(int x, int y); >+extern void undrawCursor(void); >+extern void getBoundingRectCursor(int cx, int cy, int _imageIndex, >+ int *x, int *y, int *w, int *h); >+extern int rectsIntersect(int x, int y, int w, int h, >+ int x2, int y2, int w2, int h2); >+extern int rectContains(int outX, int outY, int outW, int outH, >+ int inX, int inY, int inW, int inH); >+extern void rectsJoin(int *nx1, int *ny1, int *nw1, int *nh1, >+ int x2, int y2, int w2, int h2); >+extern void DrawZoomedScreenRegionX11Thread(Window win, int zwidth, >+ int zheight, >+ int x, int y, >+ int width, int height); >+extern void DrawScreenRegionX11Thread(Window win, int x, int y, >+ int width, int height); >+extern void Cleanup(void); >+extern XImage *CreateShmZoomImage(void); >+extern XImage *CreateShmImage(void); >+extern void ShmCleanup(void); >+extern void freeDesktopResources(void); >+ >+/* rfbproto.c */ >+ >+extern int rfbsock; >+extern Bool canUseCoRRE; >+extern Bool canUseHextile; >+extern char *desktopName; >+extern rfbPixelFormat myFormat; >+extern rfbServerInitMsg si; >+ >+extern int cursorX, cursorY; >+extern int imageIndex; >+typedef struct { >+ int set; >+ int w, h; >+ int hotX, hotY; >+ int len; >+ char *image; >+} PointerImage; >+extern PointerImage pointerImages[]; >+ >+extern int ConnectToRFBServer(const char *hostname, int port); >+extern enum InitStatus InitialiseRFBConnection(void); >+extern Bool SetFormatAndEncodings(void); >+extern Bool SendIncrementalFramebufferUpdateRequest(void); >+extern Bool SendFramebufferUpdateRequest(int x, int y, int w, int h, >+ Bool incremental); >+extern Bool SendPointerEvent(int x, int y, int buttonMask); >+extern Bool SendKeyEvent(CARD32 key, Bool down); >+extern Bool SendClientCutText(const char *str, int len); >+extern Bool HandleRFBServerMessage(void); >+ >+extern void PrintPixelFormat(rfbPixelFormat *format); >+extern void freeRFBProtoResources(void); >+extern void freeResources(void); >+ >+/* sockets.c */ >+ >+extern Bool errorMessageOnReadFailure; >+ >+extern Bool ReadFromRFBServer(char *out, unsigned int n); >+extern Bool WriteExact(int sock, const char *buf, int n); >+extern int ConnectToTcpAddr(unsigned int host, int port); >+ >+extern int StringToIPAddr(const char *str, unsigned int *addr); >+extern void freeSocketsResources(void); >+ > #if(defined __cplusplus) > } > #endif >diff -uNr tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/zlib.c tdenetwork-trinity-14.1.0/krdc/vnc/zlib.c >--- tdenetwork-trinity-14.1.0-ORIG/krdc/vnc/zlib.c 1970-01-01 03:00:00.000000000 +0300 >+++ tdenetwork-trinity-14.1.0/krdc/vnc/zlib.c 2022-09-18 07:50:27.000000000 +0300 >@@ -0,0 +1,157 @@ >+/* >+ * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. >+ * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. >+ * >+ * This is free software; you can redistribute it and/or modify >+ * it under the terms of the GNU General Public License as published by >+ * the Free Software Foundation; either version 2 of the License, or >+ * (at your option) any later version. >+ * >+ * This software is distributed in the hope that it will be useful, >+ * but WITHOUT ANY WARRANTY; without even the implied warranty of >+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >+ * GNU General Public License for more details. >+ * >+ * You should have received a copy of the GNU General Public License >+ * along with this software; if not, write to the Free Software >+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, >+ * USA. >+ */ >+ >+/* >+ * zlib.c - handle zlib encoding. >+ * >+ * This file shouldn't be compiled directly. It is included multiple times by >+ * rfbproto.c, each time with a different definition of the macro BPP. For >+ * each value of BPP, this file defines a function which handles an zlib >+ * encoded rectangle with BPP bits per pixel. >+ */ >+ >+#define HandleZlibBPP CONCAT2E(HandleZlib,BPP) >+#define CARDBPP CONCAT2E(CARD,BPP) >+ >+static Bool >+HandleZlibBPP (int rx, int ry, int rw, int rh) >+{ >+ rfbZlibHeader hdr; >+ int remaining; >+ int inflateResult; >+ int toRead; >+ >+ /* First make sure we have a large enough raw buffer to hold the >+ * decompressed data. In practice, with a fixed BPP, fixed frame >+ * buffer size and the first update containing the entire frame >+ * buffer, this buffer allocation should only happen once, on the >+ * first update. >+ */ >+ if ( raw_buffer_size < (( rw * rh ) * ( BPP / 8 ))) { >+ >+ if ( raw_buffer != NULL ) { >+ >+ free( raw_buffer ); >+ >+ } >+ >+ raw_buffer_size = (( rw * rh ) * ( BPP / 8 )); >+ raw_buffer = (char*) malloc( raw_buffer_size ); >+ >+ } >+ >+ if (!ReadFromRFBServer((char *)&hdr, sz_rfbZlibHeader)) >+ return False; >+ >+ remaining = Swap32IfLE(hdr.nBytes); >+ >+ /* Need to initialize the decompressor state. */ >+ decompStream.next_in = ( Bytef * )buffer; >+ decompStream.avail_in = 0; >+ decompStream.next_out = ( Bytef * )raw_buffer; >+ decompStream.avail_out = raw_buffer_size; >+ decompStream.data_type = Z_BINARY; >+ >+ /* Initialize the decompression stream structures on the first invocation. */ >+ if ( decompStreamInited == False ) { >+ >+ inflateResult = inflateInit( &decompStream ); >+ >+ if ( inflateResult != Z_OK ) { >+ fprintf(stderr, >+ "inflateInit returned error: %d, msg: %s\n", >+ inflateResult, >+ decompStream.msg); >+ return False; >+ } >+ >+ decompStreamInited = True; >+ >+ } >+ >+ inflateResult = Z_OK; >+ >+ /* Process buffer full of data until no more to process, or >+ * some type of inflater error, or Z_STREAM_END. >+ */ >+ while (( remaining > 0 ) && >+ ( inflateResult == Z_OK )) { >+ >+ if ( remaining > BUFFER_SIZE ) { >+ toRead = BUFFER_SIZE; >+ } >+ else { >+ toRead = remaining; >+ } >+ >+ /* Fill the buffer, obtaining data from the server. */ >+ if (!ReadFromRFBServer(buffer,toRead)) >+ return False; >+ >+ decompStream.next_in = ( Bytef * )buffer; >+ decompStream.avail_in = toRead; >+ >+ /* Need to uncompress buffer full. */ >+ inflateResult = inflate( &decompStream, Z_SYNC_FLUSH ); >+ >+ /* We never supply a dictionary for compression. */ >+ if ( inflateResult == Z_NEED_DICT ) { >+ fprintf(stderr,"zlib inflate needs a dictionary!\n"); >+ return False; >+ } >+ if ( inflateResult < 0 ) { >+ fprintf(stderr, >+ "zlib inflate returned error: %d, msg: %s\n", >+ inflateResult, >+ decompStream.msg); >+ return False; >+ } >+ >+ /* Result buffer allocated to be at least large enough. We should >+ * never run out of space! >+ */ >+ if (( decompStream.avail_in > 0 ) && >+ ( decompStream.avail_out <= 0 )) { >+ fprintf(stderr,"zlib inflate ran out of space!\n"); >+ return False; >+ } >+ >+ remaining -= toRead; >+ >+ } /* while ( remaining > 0 ) */ >+ >+ if ( inflateResult == Z_OK ) { >+ >+ /* Put the uncompressed contents of the update on the screen. */ >+ CopyDataToScreen(raw_buffer, rx, ry, rw, rh); >+ >+ } >+ else { >+ >+ fprintf(stderr, >+ "zlib inflate returned error: %d, msg: %s\n", >+ inflateResult, >+ decompStream.msg); >+ return False; >+ >+ } >+ >+ return True; >+} View Attachment As Diff View Attachment As Raw

• • Home
  • | New
  • | Browse
  • | Search
  • |
    [?]
  • | Reports
  • | Help
  • | New Account
  • | Log In
    [x]
  • | Forgot Password
    Login: [x]