blob: 54716d3eb04c60114c980f16391fcbd5f85b0177 [file] [log] [blame]
Pierre Ossman5156d5e2011-03-09 09:42:34 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
DRC33c15e32011-11-03 18:49:21 +00002 * Copyright (C) 2011 D. R. Commander. All Rights Reserved.
Pierre Ossmanfdba3fe2014-01-31 13:12:18 +01003 * Copyright 2009-2014 Pierre Ossman for Cendio AB
Pierre Ossman5156d5e2011-03-09 09:42:34 +00004 *
5 * This is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This software is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this software; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18 * USA.
19 */
20
Peter Åstrandc359f362011-08-23 12:04:46 +000021#ifdef HAVE_CONFIG_H
22#include <config.h>
23#endif
24
Pierre Ossman5156d5e2011-03-09 09:42:34 +000025#include <assert.h>
DRCb65bb932011-06-24 03:17:00 +000026#ifndef _WIN32
Pierre Ossman5156d5e2011-03-09 09:42:34 +000027#include <unistd.h>
DRCb65bb932011-06-24 03:17:00 +000028#endif
Pierre Ossman5156d5e2011-03-09 09:42:34 +000029
30#include <rfb/CMsgWriter.h>
Pierre Ossman0068a4f2015-11-09 15:48:19 +010031#include <rfb/CSecurity.h>
Pierre Ossman5156d5e2011-03-09 09:42:34 +000032#include <rfb/Hostname.h>
33#include <rfb/LogWriter.h>
Pierre Ossman0068a4f2015-11-09 15:48:19 +010034#include <rfb/Security.h>
Pierre Ossman5156d5e2011-03-09 09:42:34 +000035#include <rfb/util.h>
36#include <rfb/screenTypes.h>
Pierre Ossmane28bdb22011-11-14 16:02:06 +000037#include <rfb/fenceTypes.h>
Pierre Ossman5156d5e2011-03-09 09:42:34 +000038#include <rfb/Timer.h>
Pierre Ossmane28bdb22011-11-14 16:02:06 +000039#include <rdr/MemInStream.h>
40#include <rdr/MemOutStream.h>
Pierre Ossman5156d5e2011-03-09 09:42:34 +000041#include <network/TcpSocket.h>
42
43#include <FL/Fl.H>
44#include <FL/fl_ask.H>
45
46#include "CConn.h"
Pierre Ossmanf4f30942011-05-17 09:39:07 +000047#include "OptionsDialog.h"
Pierre Ossman947b48d2014-01-27 16:52:35 +010048#include "DesktopWindow.h"
Pierre Ossman5156d5e2011-03-09 09:42:34 +000049#include "i18n.h"
50#include "parameters.h"
Pierre Ossman39ceb502011-07-12 15:54:25 +000051#include "vncviewer.h"
Pierre Ossman5156d5e2011-03-09 09:42:34 +000052
DRCb65bb932011-06-24 03:17:00 +000053#ifdef WIN32
54#include "win32.h"
55#endif
56
Pierre Ossman5156d5e2011-03-09 09:42:34 +000057using namespace rdr;
58using namespace rfb;
59using namespace std;
60
Pierre Ossman5156d5e2011-03-09 09:42:34 +000061static rfb::LogWriter vlog("CConn");
62
Pierre Ossmancf836f22011-07-14 14:34:09 +000063// 8 colours (1 bit per component)
64static const PixelFormat verylowColourPF(8, 3,false, true,
65 1, 1, 1, 2, 1, 0);
66// 64 colours (2 bits per component)
67static const PixelFormat lowColourPF(8, 6, false, true,
68 3, 3, 3, 4, 2, 0);
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +010069// 256 colours (2-3 bits per component)
70static const PixelFormat mediumColourPF(8, 8, false, true,
71 7, 7, 3, 5, 2, 0);
Pierre Ossmanf4f30942011-05-17 09:39:07 +000072
Pierre Ossman2a7a8d62013-02-15 08:33:39 +000073CConn::CConn(const char* vncServerName, network::Socket* socket=NULL)
74 : serverHost(0), serverPort(0), desktop(NULL),
Pierre Ossman5d512c32011-11-04 11:42:16 +000075 pendingPFChange(false),
Pierre Ossman5156d5e2011-03-09 09:42:34 +000076 currentEncoding(encodingTight), lastServerEncoding((unsigned int)-1),
77 formatChange(false), encodingChange(false),
Pierre Ossmanaa73c892011-11-15 12:13:37 +000078 firstUpdate(true), pendingUpdate(false), continuousUpdates(false),
Pierre Ossmane28bdb22011-11-14 16:02:06 +000079 forceNonincremental(true), supportsSyncFence(false)
Pierre Ossman5156d5e2011-03-09 09:42:34 +000080{
81 setShared(::shared);
Pierre Ossman2a7a8d62013-02-15 08:33:39 +000082 sock = socket;
Pierre Ossman5156d5e2011-03-09 09:42:34 +000083
84 int encNum = encodingNum(preferredEncoding);
85 if (encNum != -1)
86 currentEncoding = encNum;
87
Pierre Ossmanda389562011-06-09 08:24:37 +000088 cp.supportsLocalCursor = true;
89
Pierre Ossman5156d5e2011-03-09 09:42:34 +000090 cp.supportsDesktopResize = true;
91 cp.supportsExtendedDesktopSize = true;
92 cp.supportsDesktopRename = true;
Pierre Ossman5156d5e2011-03-09 09:42:34 +000093
Pierre Ossmana22459d2014-03-17 14:42:10 +010094 if (customCompressLevel)
95 cp.compressLevel = compressLevel;
96 else
97 cp.compressLevel = -1;
Pierre Ossman5156d5e2011-03-09 09:42:34 +000098
Pierre Ossmana22459d2014-03-17 14:42:10 +010099 if (!noJpeg)
100 cp.qualityLevel = qualityLevel;
101 else
102 cp.qualityLevel = -1;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000103
Pierre Ossman2a7a8d62013-02-15 08:33:39 +0000104 if(sock == NULL) {
105 try {
106 getHostAndPort(vncServerName, &serverHost, &serverPort);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000107
Pierre Ossman2a7a8d62013-02-15 08:33:39 +0000108 sock = new network::TcpSocket(serverHost, serverPort);
109 vlog.info(_("connected to host %s port %d"), serverHost, serverPort);
110 } catch (rdr::Exception& e) {
111 vlog.error("%s", e.str());
112 fl_alert("%s", e.str());
113 exit_vncviewer();
114 return;
115 }
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000116 }
117
118 Fl::add_fd(sock->getFd(), FL_READ | FL_EXCEPT, socketEvent, this);
119
120 // See callback below
121 sock->inStream().setBlockCallback(this);
122
123 setServerName(serverHost);
124 setStreams(&sock->inStream(), &sock->outStream());
125
126 initialiseProtocol();
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000127
128 OptionsDialog::addCallback(handleOptions, this);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000129}
130
131CConn::~CConn()
132{
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000133 OptionsDialog::removeCallback(handleOptions);
Pierre Ossmand9b90032015-09-23 12:18:52 +0200134 Fl::remove_timeout(handleUpdateTimeout, this);
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000135
Pierre Ossman6a9e2e62011-05-19 14:47:43 +0000136 if (desktop)
137 delete desktop;
138
Pierre Ossman5e04c262011-11-09 11:31:12 +0000139 delete [] serverHost;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000140 if (sock)
141 Fl::remove_fd(sock->getFd());
142 delete sock;
143}
144
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000145void CConn::refreshFramebuffer()
146{
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000147 forceNonincremental = true;
148
149 // Without fences, we cannot safely trigger an update request directly
150 // but must wait for the next update to arrive.
151 if (supportsSyncFence)
152 requestNewUpdate();
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000153}
154
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000155const char *CConn::connectionInfo()
156{
157 static char infoText[1024] = "";
158
Pierre Ossmanb2046432014-09-22 11:17:34 +0200159 char scratch[100];
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000160 char pfStr[100];
Pierre Ossmanb2046432014-09-22 11:17:34 +0200161
162 // Crude way of avoiding constant overflow checks
163 assert((sizeof(scratch) + 1) * 10 < sizeof(infoText));
164
165 infoText[0] = '\0';
166
167 snprintf(scratch, sizeof(scratch),
168 _("Desktop name: %.80s"), cp.name());
169 strcat(infoText, scratch);
170 strcat(infoText, "\n");
171
172 snprintf(scratch, sizeof(scratch),
173 _("Host: %.80s port: %d"), serverHost, serverPort);
174 strcat(infoText, scratch);
175 strcat(infoText, "\n");
176
177 snprintf(scratch, sizeof(scratch),
178 _("Size: %d x %d"), cp.width, cp.height);
179 strcat(infoText, scratch);
180 strcat(infoText, "\n");
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000181
Pierre Ossman744e55c2014-12-03 14:00:54 +0100182 // TRANSLATORS: Will be filled in with a string describing the
183 // protocol pixel format in a fairly language neutral way
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000184 cp.pf().print(pfStr, 100);
Pierre Ossmanb2046432014-09-22 11:17:34 +0200185 snprintf(scratch, sizeof(scratch),
186 _("Pixel format: %s"), pfStr);
187 strcat(infoText, scratch);
188 strcat(infoText, "\n");
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000189
Pierre Ossman744e55c2014-12-03 14:00:54 +0100190 // TRANSLATORS: Similar to the earlier "Pixel format" string
Pierre Ossmanb2046432014-09-22 11:17:34 +0200191 serverPF.print(pfStr, 100);
192 snprintf(scratch, sizeof(scratch),
193 _("(server default %s)"), pfStr);
194 strcat(infoText, scratch);
195 strcat(infoText, "\n");
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000196
Pierre Ossmanb2046432014-09-22 11:17:34 +0200197 snprintf(scratch, sizeof(scratch),
198 _("Requested encoding: %s"), encodingName(currentEncoding));
199 strcat(infoText, scratch);
200 strcat(infoText, "\n");
201
202 snprintf(scratch, sizeof(scratch),
203 _("Last used encoding: %s"), encodingName(lastServerEncoding));
204 strcat(infoText, scratch);
205 strcat(infoText, "\n");
206
207 snprintf(scratch, sizeof(scratch),
208 _("Line speed estimate: %d kbit/s"), sock->inStream().kbitsPerSecond());
209 strcat(infoText, scratch);
210 strcat(infoText, "\n");
211
212 snprintf(scratch, sizeof(scratch),
213 _("Protocol version: %d.%d"), cp.majorVersion, cp.minorVersion);
214 strcat(infoText, scratch);
215 strcat(infoText, "\n");
216
217 snprintf(scratch, sizeof(scratch),
218 _("Security method: %s"), secTypeName(csecurity->getType()));
219 strcat(infoText, scratch);
220 strcat(infoText, "\n");
Pierre Ossman2eb1d112011-05-16 12:18:08 +0000221
222 return infoText;
223}
224
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000225// The RFB core is not properly asynchronous, so it calls this callback
226// whenever it needs to block to wait for more data. Since FLTK is
227// monitoring the socket, we just make sure FLTK gets to run.
228
229void CConn::blockCallback()
230{
231 int next_timer;
232
233 next_timer = Timer::checkTimeouts();
234 if (next_timer == 0)
235 next_timer = INT_MAX;
236
237 Fl::wait((double)next_timer / 1000.0);
Pierre Ossman1db73242015-09-23 12:20:32 +0200238
239 if (should_exit())
240 throw rdr::Exception("Termination requested");
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000241}
242
DRC3e7ed812013-02-26 10:34:22 +0000243void CConn::socketEvent(FL_SOCKET fd, void *data)
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000244{
245 CConn *cc;
246 static bool recursing = false;
247
248 assert(data);
249 cc = (CConn*)data;
250
251 // I don't think processMsg() is recursion safe, so add this check
252 if (recursing)
253 return;
254
255 recursing = true;
256
257 try {
258 // processMsg() only processes one message, so we need to loop
259 // until the buffers are empty or things will stall.
260 do {
261 cc->processMsg();
262 } while (cc->sock->inStream().checkNoWait(1));
263 } catch (rdr::EndOfStream& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000264 vlog.info("%s", e.str());
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000265 exit_vncviewer();
266 } catch (rdr::Exception& e) {
Pierre Ossmanad8609a2012-04-26 09:04:14 +0000267 vlog.error("%s", e.str());
Pierre Ossman1db73242015-09-23 12:20:32 +0200268 // Somebody might already have requested us to terminate, and
269 // might have already provided an error message.
270 if (!should_exit())
271 exit_vncviewer(e.str());
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000272 }
273
274 recursing = false;
275}
276
277////////////////////// CConnection callback methods //////////////////////
278
279// serverInit() is called when the serverInit message has been received. At
280// this point we create the desktop window and display it. We also tell the
281// server the pixel format and encodings to use and request the first update.
282void CConn::serverInit()
283{
284 CConnection::serverInit();
285
286 // If using AutoSelect with old servers, start in FullColor
287 // mode. See comment in autoSelectFormatAndEncoding.
288 if (cp.beforeVersion(3, 8) && autoSelect)
289 fullColour.setParam(true);
290
291 serverPF = cp.pf();
292
293 desktop = new DesktopWindow(cp.width, cp.height, cp.name(), serverPF, this);
294 fullColourPF = desktop->getPreferredPF();
295
Pierre Ossman5d512c32011-11-04 11:42:16 +0000296 // Force a switch to the format and encoding we'd like
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000297 formatChange = encodingChange = true;
Pierre Ossman5d512c32011-11-04 11:42:16 +0000298
299 // And kick off the update cycle
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000300 requestNewUpdate();
Pierre Ossman5d512c32011-11-04 11:42:16 +0000301
302 // This initial update request is a bit of a corner case, so we need
303 // to help out setting the correct format here.
304 assert(pendingPFChange);
Pierre Ossman5d512c32011-11-04 11:42:16 +0000305 cp.setPF(pendingPF);
306 pendingPFChange = false;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000307}
308
309// setDesktopSize() is called when the desktop size changes (including when
310// it is set initially).
311void CConn::setDesktopSize(int w, int h)
312{
313 CConnection::setDesktopSize(w,h);
314 resizeFramebuffer();
315}
316
317// setExtendedDesktopSize() is a more advanced version of setDesktopSize()
Pierre Ossman28c1d542015-03-03 16:27:44 +0100318void CConn::setExtendedDesktopSize(unsigned reason, unsigned result,
319 int w, int h, const rfb::ScreenSet& layout)
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000320{
321 CConnection::setExtendedDesktopSize(reason, result, w, h, layout);
322
323 if ((reason == reasonClient) && (result != resultSuccess)) {
324 vlog.error(_("SetDesktopSize failed: %d"), result);
325 return;
326 }
327
328 resizeFramebuffer();
329}
330
331// setName() is called when the desktop name changes
332void CConn::setName(const char* name)
333{
334 CConnection::setName(name);
335 if (desktop)
336 desktop->setName(name);
337}
338
339// framebufferUpdateStart() is called at the beginning of an update.
340// Here we try to send out a new framebuffer update request so that the
341// next update can be sent out in parallel with us decoding the current
Pierre Ossman5d512c32011-11-04 11:42:16 +0000342// one.
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000343void CConn::framebufferUpdateStart()
344{
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000345 // Note: This might not be true if sync fences are supported
Pierre Ossman5d512c32011-11-04 11:42:16 +0000346 pendingUpdate = false;
347
348 requestNewUpdate();
Pierre Ossmand9b90032015-09-23 12:18:52 +0200349
350 // Update the screen prematurely for very slow updates
351 Fl::add_timeout(1.0, handleUpdateTimeout, this);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000352}
353
354// framebufferUpdateEnd() is called at the end of an update.
355// For each rectangle, the FdInStream will have timed the speed
356// of the connection, allowing us to select format and encoding
357// appropriately, and then request another incremental update.
358void CConn::framebufferUpdateEnd()
359{
Pierre Ossmand9b90032015-09-23 12:18:52 +0200360 Fl::remove_timeout(handleUpdateTimeout, this);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000361 desktop->updateWindow();
362
363 if (firstUpdate) {
Pierre Ossmanaa73c892011-11-15 12:13:37 +0000364 // We need fences to make extra update requests and continuous
365 // updates "safe". See fence() for the next step.
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000366 if (cp.supportsFence)
367 writer()->writeFence(fenceFlagRequest | fenceFlagSyncNext, 0, NULL);
368
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000369 firstUpdate = false;
370 }
371
Pierre Ossman5d512c32011-11-04 11:42:16 +0000372 // A format change has been scheduled and we are now past the update
373 // with the old format. Time to active the new one.
374 if (pendingPFChange) {
Pierre Ossman5d512c32011-11-04 11:42:16 +0000375 cp.setPF(pendingPF);
376 pendingPFChange = false;
377 }
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000378
379 // Compute new settings based on updated bandwidth values
380 if (autoSelect)
381 autoSelectFormatAndEncoding();
382
383 // Make sure that the FLTK handling and the timers gets some CPU time
384 // in case of back to back framebuffer updates.
385 Fl::check();
386 Timer::checkTimeouts();
387}
388
389// The rest of the callbacks are fairly self-explanatory...
390
391void CConn::setColourMapEntries(int firstColour, int nColours, rdr::U16* rgbs)
392{
Pierre Ossman8ca4c1d2014-09-22 12:54:26 +0200393 vlog.error(_("Invalid SetColourMapEntries from server!"));
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000394}
395
396void CConn::bell()
397{
398 fl_beep();
399}
400
401void CConn::serverCutText(const char* str, rdr::U32 len)
402{
Pierre Ossman689c4582011-05-26 15:39:41 +0000403 char *buffer;
404 int size, ret;
Pierre Ossmand81e8f42011-05-19 14:47:15 +0000405
Pierre Ossman50104882013-05-24 10:47:27 +0000406 if (!acceptClipboard)
407 return;
408
Pierre Ossman689c4582011-05-26 15:39:41 +0000409 size = fl_utf8froma(NULL, 0, str, len);
410 if (size <= 0)
Pierre Ossmand81e8f42011-05-19 14:47:15 +0000411 return;
Pierre Ossman689c4582011-05-26 15:39:41 +0000412
413 size++;
414
415 buffer = new char[size];
416
417 ret = fl_utf8froma(buffer, size, str, len);
418 assert(ret < size);
Pierre Ossmand81e8f42011-05-19 14:47:15 +0000419
Pierre Ossmanfb450fb2015-03-03 16:34:56 +0100420 vlog.debug("Got clipboard data (%d bytes)", (int)strlen(buffer));
Pierre Ossmand81e8f42011-05-19 14:47:15 +0000421
Pierre Ossmancf2443c2011-09-07 09:01:20 +0000422 // RFB doesn't have separate selection and clipboard concepts, so we
423 // dump the data into both variants.
424 Fl::copy(buffer, ret, 0);
Pierre Ossmand81e8f42011-05-19 14:47:15 +0000425 Fl::copy(buffer, ret, 1);
Pierre Ossman689c4582011-05-26 15:39:41 +0000426
427 delete [] buffer;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000428}
429
Pierre Ossmanfdba3fe2014-01-31 13:12:18 +0100430void CConn::dataRect(const Rect& r, int encoding)
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000431{
432 sock->inStream().startTiming();
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000433
Pierre Ossmanfdba3fe2014-01-31 13:12:18 +0100434 if (encoding != encodingCopyRect)
435 lastServerEncoding = encoding;
436
Pierre Ossman9f273e92015-11-09 16:34:54 +0100437 CConnection::dataRect(r, encoding);
Pierre Ossmanfdba3fe2014-01-31 13:12:18 +0100438
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000439 sock->inStream().stopTiming();
440}
441
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000442void CConn::setCursor(int width, int height, const Point& hotspot,
443 void* data, void* mask)
444{
Pierre Ossman835b4ef2011-06-08 17:02:36 +0000445 desktop->setCursor(width, height, hotspot, data, mask);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000446}
447
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000448void CConn::fence(rdr::U32 flags, unsigned len, const char data[])
449{
450 CMsgHandler::fence(flags, len, data);
451
452 if (flags & fenceFlagRequest) {
453 // We handle everything synchronously so we trivially honor these modes
454 flags = flags & (fenceFlagBlockBefore | fenceFlagBlockAfter);
455
456 writer()->writeFence(flags, len, data);
457 return;
458 }
459
460 if (len == 0) {
461 // Initial probe
Pierre Ossmanaa73c892011-11-15 12:13:37 +0000462 if (flags & fenceFlagSyncNext) {
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000463 supportsSyncFence = true;
Pierre Ossmanaa73c892011-11-15 12:13:37 +0000464
465 if (cp.supportsContinuousUpdates) {
466 vlog.info(_("Enabling continuous updates"));
467 continuousUpdates = true;
468 writer()->writeEnableContinuousUpdates(true, 0, 0, cp.width, cp.height);
469 }
470 }
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000471 } else {
472 // Pixel format change
473 rdr::MemInStream memStream(data, len);
474 PixelFormat pf;
475
476 pf.read(&memStream);
477
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000478 cp.setPF(pf);
479 }
480}
481
DRC33c15e32011-11-03 18:49:21 +0000482
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000483////////////////////// Internal methods //////////////////////
484
485void CConn::resizeFramebuffer()
486{
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000487 if (!desktop)
488 return;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000489
Pierre Ossmanaa73c892011-11-15 12:13:37 +0000490 if (continuousUpdates)
491 writer()->writeEnableContinuousUpdates(true, 0, 0, cp.width, cp.height);
492
Pierre Ossman6455d852011-06-01 09:33:00 +0000493 desktop->resizeFramebuffer(cp.width, cp.height);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000494}
495
496// autoSelectFormatAndEncoding() chooses the format and encoding appropriate
497// to the connection speed:
498//
499// First we wait for at least one second of bandwidth measurement.
500//
501// Above 16Mbps (i.e. LAN), we choose the second highest JPEG quality,
502// which should be perceptually lossless.
503//
504// If the bandwidth is below that, we choose a more lossy JPEG quality.
505//
506// If the bandwidth drops below 256 Kbps, we switch to palette mode.
507//
508// Note: The system here is fairly arbitrary and should be replaced
509// with something more intelligent at the server end.
510//
511void CConn::autoSelectFormatAndEncoding()
512{
513 int kbitsPerSecond = sock->inStream().kbitsPerSecond();
514 unsigned int timeWaited = sock->inStream().timeWaited();
515 bool newFullColour = fullColour;
516 int newQualityLevel = qualityLevel;
517
518 // Always use Tight
519 if (currentEncoding != encodingTight) {
520 currentEncoding = encodingTight;
521 encodingChange = true;
522 }
523
524 // Check that we have a decent bandwidth measurement
525 if ((kbitsPerSecond == 0) || (timeWaited < 10000))
526 return;
527
528 // Select appropriate quality level
529 if (!noJpeg) {
530 if (kbitsPerSecond > 16000)
531 newQualityLevel = 8;
532 else
533 newQualityLevel = 6;
534
535 if (newQualityLevel != qualityLevel) {
536 vlog.info(_("Throughput %d kbit/s - changing to quality %d"),
537 kbitsPerSecond, newQualityLevel);
538 cp.qualityLevel = newQualityLevel;
539 qualityLevel.setParam(newQualityLevel);
540 encodingChange = true;
541 }
542 }
543
544 if (cp.beforeVersion(3, 8)) {
545 // Xvnc from TightVNC 1.2.9 sends out FramebufferUpdates with
546 // cursors "asynchronously". If this happens in the middle of a
547 // pixel format change, the server will encode the cursor with
548 // the old format, but the client will try to decode it
549 // according to the new format. This will lead to a
550 // crash. Therefore, we do not allow automatic format change for
551 // old servers.
552 return;
553 }
554
555 // Select best color level
556 newFullColour = (kbitsPerSecond > 256);
557 if (newFullColour != fullColour) {
558 vlog.info(_("Throughput %d kbit/s - full color is now %s"),
559 kbitsPerSecond,
560 newFullColour ? _("enabled") : _("disabled"));
561 fullColour.setParam(newFullColour);
562 formatChange = true;
563 }
564}
565
566// checkEncodings() sends a setEncodings message if one is needed.
567void CConn::checkEncodings()
568{
569 if (encodingChange && writer()) {
570 vlog.info(_("Using %s encoding"),encodingName(currentEncoding));
571 writer()->writeSetEncodings(currentEncoding, true);
572 encodingChange = false;
573 }
574}
575
576// requestNewUpdate() requests an update from the server, having set the
577// format and encoding appropriately.
578void CConn::requestNewUpdate()
579{
580 if (formatChange) {
581 PixelFormat pf;
582
583 /* Catch incorrect requestNewUpdate calls */
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000584 assert(!pendingUpdate || supportsSyncFence);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000585
586 if (fullColour) {
587 pf = fullColourPF;
588 } else {
589 if (lowColourLevel == 0)
Pierre Ossmancf836f22011-07-14 14:34:09 +0000590 pf = verylowColourPF;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000591 else if (lowColourLevel == 1)
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000592 pf = lowColourPF;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000593 else
Pierre Ossmancf836f22011-07-14 14:34:09 +0000594 pf = mediumColourPF;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000595 }
Pierre Ossman5d512c32011-11-04 11:42:16 +0000596
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000597 if (supportsSyncFence) {
598 // We let the fence carry the pixel format and switch once we
599 // get the response back. That way we will be synchronised with
600 // when the server switches.
601 rdr::MemOutStream memStream;
602
603 pf.write(&memStream);
604
605 writer()->writeFence(fenceFlagRequest | fenceFlagSyncNext,
606 memStream.length(), (const char*)memStream.data());
607 } else {
608 // New requests are sent out at the start of processing the last
609 // one, so we cannot switch our internal format right now (doing so
610 // would mean misdecoding the current update).
611 pendingPFChange = true;
612 pendingPF = pf;
613 }
Pierre Ossman5d512c32011-11-04 11:42:16 +0000614
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000615 char str[256];
616 pf.print(str, 256);
617 vlog.info(_("Using pixel format %s"),str);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000618 writer()->writeSetPixelFormat(pf);
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000619
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000620 formatChange = false;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000621 }
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000622
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000623 checkEncodings();
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000624
Pierre Ossmanaa73c892011-11-15 12:13:37 +0000625 if (forceNonincremental || !continuousUpdates) {
626 pendingUpdate = true;
627 writer()->writeFramebufferUpdateRequest(Rect(0, 0, cp.width, cp.height),
628 !forceNonincremental);
629 }
Pierre Ossmand4c61ce2011-04-29 11:18:12 +0000630
631 forceNonincremental = false;
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000632}
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000633
634void CConn::handleOptions(void *data)
635{
636 CConn *self = (CConn*)data;
637
638 // Checking all the details of the current set of encodings is just
639 // a pain. Assume something has changed, as resending the encoding
640 // list is cheap. Avoid overriding what the auto logic has selected
641 // though.
642 if (!autoSelect) {
643 int encNum = encodingNum(preferredEncoding);
644
645 if (encNum != -1)
646 self->currentEncoding = encNum;
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000647 }
648
Pierre Ossmanda389562011-06-09 08:24:37 +0000649 self->cp.supportsLocalCursor = true;
650
Pierre Ossmana22459d2014-03-17 14:42:10 +0100651 if (customCompressLevel)
652 self->cp.compressLevel = compressLevel;
653 else
654 self->cp.compressLevel = -1;
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000655
Pierre Ossmana22459d2014-03-17 14:42:10 +0100656 if (!noJpeg && !autoSelect)
657 self->cp.qualityLevel = qualityLevel;
658 else
659 self->cp.qualityLevel = -1;
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000660
661 self->encodingChange = true;
662
663 // Format changes refreshes the entire screen though and are therefore
664 // very costly. It's probably worth the effort to see if it is necessary
665 // here.
666 PixelFormat pf;
667
668 if (fullColour) {
669 pf = self->fullColourPF;
670 } else {
671 if (lowColourLevel == 0)
Pierre Ossmancf836f22011-07-14 14:34:09 +0000672 pf = verylowColourPF;
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000673 else if (lowColourLevel == 1)
674 pf = lowColourPF;
675 else
Pierre Ossmancf836f22011-07-14 14:34:09 +0000676 pf = mediumColourPF;
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000677 }
678
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000679 if (!pf.equal(self->cp.pf())) {
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000680 self->formatChange = true;
Pierre Ossmane28bdb22011-11-14 16:02:06 +0000681
682 // Without fences, we cannot safely trigger an update request directly
683 // but must wait for the next update to arrive.
684 if (self->supportsSyncFence)
685 self->requestNewUpdate();
686 }
Pierre Ossmanf4f30942011-05-17 09:39:07 +0000687}
Pierre Ossmand9b90032015-09-23 12:18:52 +0200688
689void CConn::handleUpdateTimeout(void *data)
690{
691 CConn *self = (CConn *)data;
692
693 assert(self);
694
695 self->desktop->updateWindow();
696
697 Fl::repeat_timeout(1.0, handleUpdateTimeout, data);
698}