blob: c95c14f068c4c0ab498403ebca7c304c8772c08a [file] [log] [blame]
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +01002 * Copyright 2009-2018 Pierre Ossman for Cendio AB
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +00003 *
4 * This is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this software; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17 * USA.
18 */
19
20// -=- Single-Threaded VNC Server implementation
21
22
23// Note about how sockets get closed:
24//
25// Closing sockets to clients is non-trivial because the code which calls
26// VNCServerST must explicitly know about all the sockets (so that it can block
27// on them appropriately). However, VNCServerST may want to close clients for
28// a number of reasons, and from a variety of entry points. The simplest is
29// when processSocketEvent() is called for a client, and the remote end has
30// closed its socket. A more complex reason is when processSocketEvent() is
31// called for a client which has just sent a ClientInit with the shared flag
32// set to false - in this case we want to close all other clients. Yet another
33// reason for disconnecting clients is when the desktop size has changed as a
34// result of a call to setPixelBuffer().
35//
36// The responsibility for creating and deleting sockets is entirely with the
37// calling code. When VNCServerST wants to close a connection to a client it
38// calls the VNCSConnectionST's close() method which calls shutdown() on the
39// socket. Eventually the calling code will notice that the socket has been
40// shut down and call removeSocket() so that we can delete the
41// VNCSConnectionST. Note that the socket must not be deleted by the calling
42// code until after removeSocket() has been called.
43//
44// One minor complication is that we don't allocate a VNCSConnectionST object
45// for a blacklisted host (since we want to minimise the resources used for
46// dealing with such a connection). In order to properly implement the
47// getSockets function, we must maintain a separate closingSockets list,
48// otherwise blacklisted connections might be "forgotten".
49
50
Pierre Ossman559a2e82012-01-23 15:54:11 +000051#include <assert.h>
Pierre Ossmanf99c5712009-03-13 14:41:27 +000052#include <stdlib.h>
53
Pierre Ossman707fa122015-12-11 20:21:20 +010054#include <rfb/ComparingUpdateTracker.h>
55#include <rfb/KeyRemapper.h>
Pierre Ossman6c97fa42018-10-05 17:35:51 +020056#include <rfb/LogWriter.h>
Pierre Ossman707fa122015-12-11 20:21:20 +010057#include <rfb/Security.h>
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000058#include <rfb/ServerCore.h>
59#include <rfb/VNCServerST.h>
60#include <rfb/VNCSConnectionST.h>
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000061#include <rfb/util.h>
Pierre Ossmanbb305ca2016-12-11 12:41:26 +010062#include <rfb/ledStates.h>
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000063
64#include <rdr/types.h>
65
66using namespace rfb;
67
68static LogWriter slog("VNCServerST");
Pierre Ossman6c97fa42018-10-05 17:35:51 +020069static LogWriter connectionsLog("Connections");
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000070
71//
72// -=- VNCServerST Implementation
73//
74
75// -=- Constructors/Destructor
76
Adam Tkaca6578bf2010-04-23 14:07:41 +000077VNCServerST::VNCServerST(const char* name_, SDesktop* desktop_)
Pierre Ossman559a2e82012-01-23 15:54:11 +000078 : blHosts(&blacklist), desktop(desktop_), desktopStarted(false),
Pierre Ossmanbb305ca2016-12-11 12:41:26 +010079 blockCounter(0), pb(0), ledState(ledUnknown),
Adam Tkacd36b6262009-09-04 10:57:20 +000080 name(strDup(name_)), pointerClient(0), comparer(0),
Pierre Ossman6a1a0d02017-02-19 15:48:17 +010081 cursor(new Cursor(0, 0, Point(), NULL)),
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000082 renderedCursorInvalid(false),
Pierre Ossmaneef6c9a2018-10-05 17:11:25 +020083 keyRemapper(&KeyRemapper::defInstance),
Pierre Ossmanf43137c2018-10-26 15:34:03 +020084 idleTimer(this), disconnectTimer(this), connectTimer(this),
85 frameTimer(this)
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000086{
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000087 slog.debug("creating single-threaded server %s", name.buf);
Pierre Ossmanf43137c2018-10-26 15:34:03 +020088
89 // FIXME: Do we really want to kick off these right away?
90 if (rfb::Server::maxIdleTime)
91 idleTimer.start(secsToMillis(rfb::Server::maxIdleTime));
92 if (rfb::Server::maxDisconnectionTime)
93 disconnectTimer.start(secsToMillis(rfb::Server::maxDisconnectionTime));
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000094}
95
96VNCServerST::~VNCServerST()
97{
98 slog.debug("shutting down server %s", name.buf);
99
100 // Close any active clients, with appropriate logging & cleanup
101 closeClients("Server shutdown");
102
Pierre Ossman6e49e952016-10-07 15:59:38 +0200103 // Stop trying to render things
104 stopFrameClock();
105
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000106 // Delete all the clients, and their sockets, and any closing sockets
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000107 while (!clients.empty()) {
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200108 VNCSConnectionST* client;
109 client = clients.front();
110 clients.pop_front();
111 delete client;
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000112 }
113
114 // Stop the desktop object if active, *only* after deleting all clients!
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +0100115 stopDesktop();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000116
Pierre Ossman05338bc2016-11-08 14:57:11 +0100117 if (comparer)
118 comparer->logStats();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000119 delete comparer;
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100120
121 delete cursor;
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000122}
123
124
125// SocketServer methods
126
127void VNCServerST::addSocket(network::Socket* sock, bool outgoing)
128{
129 // - Check the connection isn't black-marked
130 // *** do this in getSecurity instead?
131 CharArray address(sock->getPeerAddress());
132 if (blHosts->isBlackmarked(address.buf)) {
133 connectionsLog.error("blacklisted: %s", address.buf);
134 try {
Pierre Ossman4bba2462018-10-11 07:52:50 +0200135 rdr::OutStream& os = sock->outStream();
136
137 // Shortest possible way to tell a client it is not welcome
138 os.writeBytes("RFB 003.003\n", 12);
139 os.writeU32(0);
140 os.writeString("Too many security failures");
141 os.flush();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000142 } catch (rdr::Exception&) {
143 }
144 sock->shutdown();
145 closingSockets.push_back(sock);
146 return;
147 }
148
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200149 CharArray name;
150 name.buf = sock->getPeerEndpoint();
151 connectionsLog.status("accepted: %s", name.buf);
152
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200153 // Adjust the exit timers
154 if (rfb::Server::maxConnectionTime && clients.empty())
155 connectTimer.start(secsToMillis(rfb::Server::maxConnectionTime));
156 disconnectTimer.stop();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000157
158 VNCSConnectionST* client = new VNCSConnectionST(this, sock, outgoing);
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200159 clients.push_front(client);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000160 client->init();
161}
162
163void VNCServerST::removeSocket(network::Socket* sock) {
164 // - If the socket has resources allocated to it, delete them
165 std::list<VNCSConnectionST*>::iterator ci;
166 for (ci = clients.begin(); ci != clients.end(); ci++) {
167 if ((*ci)->getSock() == sock) {
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200168 clients.remove(*ci);
169
Pierre Ossmanb6843412018-10-05 17:30:52 +0200170 // - Release the cursor if this client owns it
171 if (pointerClient == *ci)
172 pointerClient = NULL;
173
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200174 // Adjust the exit timers
175 connectTimer.stop();
176 if (rfb::Server::maxDisconnectionTime && clients.empty())
177 disconnectTimer.start(secsToMillis(rfb::Server::maxDisconnectionTime));
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200178
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000179 // - Delete the per-Socket resources
180 delete *ci;
181
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200182 CharArray name;
183 name.buf = sock->getPeerEndpoint();
184 connectionsLog.status("closed: %s", name.buf);
185
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000186 // - Check that the desktop object is still required
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +0100187 if (authClientCount() == 0)
188 stopDesktop();
Pierre Ossman05338bc2016-11-08 14:57:11 +0100189
190 if (comparer)
191 comparer->logStats();
192
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000193 return;
194 }
195 }
196
197 // - If the Socket has no resources, it may have been a closingSocket
198 closingSockets.remove(sock);
199}
200
Pierre Ossmand408ca52016-04-29 14:26:05 +0200201void VNCServerST::processSocketReadEvent(network::Socket* sock)
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000202{
203 // - Find the appropriate VNCSConnectionST and process the event
204 std::list<VNCSConnectionST*>::iterator ci;
205 for (ci = clients.begin(); ci != clients.end(); ci++) {
206 if ((*ci)->getSock() == sock) {
207 (*ci)->processMessages();
208 return;
209 }
210 }
211 throw rdr::Exception("invalid Socket in VNCServerST");
212}
213
Pierre Ossmand408ca52016-04-29 14:26:05 +0200214void VNCServerST::processSocketWriteEvent(network::Socket* sock)
215{
216 // - Find the appropriate VNCSConnectionST and process the event
217 std::list<VNCSConnectionST*>::iterator ci;
218 for (ci = clients.begin(); ci != clients.end(); ci++) {
219 if ((*ci)->getSock() == sock) {
220 (*ci)->flushSocket();
221 return;
222 }
223 }
224 throw rdr::Exception("invalid Socket in VNCServerST");
225}
226
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000227// VNCServer methods
228
Pierre Ossman559a2e82012-01-23 15:54:11 +0000229void VNCServerST::blockUpdates()
230{
231 blockCounter++;
Pierre Ossman6e49e952016-10-07 15:59:38 +0200232
233 stopFrameClock();
Pierre Ossman559a2e82012-01-23 15:54:11 +0000234}
235
236void VNCServerST::unblockUpdates()
237{
238 assert(blockCounter > 0);
239
240 blockCounter--;
241
Pierre Ossman6e49e952016-10-07 15:59:38 +0200242 // Restart the frame clock if we have updates
243 if (blockCounter == 0) {
244 if (!comparer->is_empty())
245 startFrameClock();
246 }
Pierre Ossman559a2e82012-01-23 15:54:11 +0000247}
248
Pierre Ossman04e62db2009-03-23 16:57:07 +0000249void VNCServerST::setPixelBuffer(PixelBuffer* pb_, const ScreenSet& layout)
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000250{
Pierre Ossman05338bc2016-11-08 14:57:11 +0100251 if (comparer)
252 comparer->logStats();
253
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000254 pb = pb_;
255 delete comparer;
256 comparer = 0;
257
Pierre Ossman04e62db2009-03-23 16:57:07 +0000258 if (!pb) {
Michal Srb28d570d2017-09-29 14:45:33 +0200259 screenLayout = ScreenSet();
260
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000261 if (desktopStarted)
262 throw Exception("setPixelBuffer: null PixelBuffer when desktopStarted?");
Michal Srb28d570d2017-09-29 14:45:33 +0200263
Pierre Ossman04e62db2009-03-23 16:57:07 +0000264 return;
265 }
266
Pierre Ossmanc3826bb2018-11-01 16:10:19 +0100267 if (!layout.validate(pb->width(), pb->height()))
268 throw Exception("setPixelBuffer: invalid screen layout");
269
270 screenLayout = layout;
271
Pierre Ossman6cd61172018-05-07 14:24:56 +0200272 // Assume the framebuffer contents wasn't saved and reset everything
273 // that tracks its contents
Pierre Ossman04e62db2009-03-23 16:57:07 +0000274 comparer = new ComparingUpdateTracker(pb);
Pierre Ossman6ea6e1a2014-02-12 16:33:43 +0100275 renderedCursorInvalid = true;
Pierre Ossman6cd61172018-05-07 14:24:56 +0200276 add_changed(pb->getRect());
Pierre Ossman04e62db2009-03-23 16:57:07 +0000277
Pierre Ossman04e62db2009-03-23 16:57:07 +0000278 std::list<VNCSConnectionST*>::iterator ci, ci_next;
279 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
280 ci_next = ci; ci_next++;
281 (*ci)->pixelBufferChange();
282 // Since the new pixel buffer means an ExtendedDesktopSize needs to
283 // be sent anyway, we don't need to call screenLayoutChange.
284 }
285}
286
287void VNCServerST::setPixelBuffer(PixelBuffer* pb_)
288{
Michal Srb28d570d2017-09-29 14:45:33 +0200289 ScreenSet layout = screenLayout;
Pierre Ossman04e62db2009-03-23 16:57:07 +0000290
291 // Check that the screen layout is still valid
Michal Srb28d570d2017-09-29 14:45:33 +0200292 if (pb_ && !layout.validate(pb_->width(), pb_->height())) {
Pierre Ossman04e62db2009-03-23 16:57:07 +0000293 Rect fbRect;
294 ScreenSet::iterator iter, iter_next;
295
296 fbRect.setXYWH(0, 0, pb_->width(), pb_->height());
297
298 for (iter = layout.begin();iter != layout.end();iter = iter_next) {
299 iter_next = iter; ++iter_next;
300 if (iter->dimensions.enclosed_by(fbRect))
301 continue;
302 iter->dimensions = iter->dimensions.intersect(fbRect);
303 if (iter->dimensions.is_empty()) {
304 slog.info("Removing screen %d (%x) as it is completely outside the new framebuffer",
305 (int)iter->id, (unsigned)iter->id);
306 layout.remove_screen(iter->id);
307 }
308 }
309 }
310
Pierre Ossmanc3826bb2018-11-01 16:10:19 +0100311 // Make sure that we have at least one screen
312 if (layout.num_screens() == 0)
313 layout.add_screen(Screen(0, 0, 0, pb->width(), pb->height(), 0));
314
Pierre Ossman04e62db2009-03-23 16:57:07 +0000315 setPixelBuffer(pb_, layout);
316}
317
318void VNCServerST::setScreenLayout(const ScreenSet& layout)
319{
320 if (!pb)
321 throw Exception("setScreenLayout: new screen layout without a PixelBuffer");
322 if (!layout.validate(pb->width(), pb->height()))
323 throw Exception("setScreenLayout: invalid screen layout");
324
Pierre Ossmandf453202009-04-02 14:26:45 +0000325 screenLayout = layout;
326
Pierre Ossman04e62db2009-03-23 16:57:07 +0000327 std::list<VNCSConnectionST*>::iterator ci, ci_next;
328 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
329 ci_next = ci; ci_next++;
Pierre Ossmana3ac01e2011-11-07 21:13:54 +0000330 (*ci)->screenLayoutChangeOrClose(reasonServer);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000331 }
332}
333
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000334void VNCServerST::bell()
335{
336 std::list<VNCSConnectionST*>::iterator ci, ci_next;
337 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
338 ci_next = ci; ci_next++;
Pierre Ossmana3ac01e2011-11-07 21:13:54 +0000339 (*ci)->bellOrClose();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000340 }
341}
342
343void VNCServerST::serverCutText(const char* str, int len)
344{
345 std::list<VNCSConnectionST*>::iterator ci, ci_next;
346 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
347 ci_next = ci; ci_next++;
Pierre Ossmana3ac01e2011-11-07 21:13:54 +0000348 (*ci)->serverCutTextOrClose(str, len);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000349 }
350}
351
Peter Ã…strandc39e0782009-01-15 12:21:42 +0000352void VNCServerST::setName(const char* name_)
353{
Adam Tkacd36b6262009-09-04 10:57:20 +0000354 name.replaceBuf(strDup(name_));
Peter Ã…strandc39e0782009-01-15 12:21:42 +0000355 std::list<VNCSConnectionST*>::iterator ci, ci_next;
356 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
357 ci_next = ci; ci_next++;
Pierre Ossmana3ac01e2011-11-07 21:13:54 +0000358 (*ci)->setDesktopNameOrClose(name_);
Peter Ã…strandc39e0782009-01-15 12:21:42 +0000359 }
360}
361
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000362void VNCServerST::add_changed(const Region& region)
363{
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000364 if (comparer == NULL)
365 return;
366
367 comparer->add_changed(region);
Pierre Ossman6e49e952016-10-07 15:59:38 +0200368 startFrameClock();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000369}
370
371void VNCServerST::add_copied(const Region& dest, const Point& delta)
372{
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000373 if (comparer == NULL)
374 return;
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000375
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000376 comparer->add_copied(dest, delta);
Pierre Ossman6e49e952016-10-07 15:59:38 +0200377 startFrameClock();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000378}
379
380void VNCServerST::setCursor(int width, int height, const Point& newHotspot,
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100381 const rdr::U8* data)
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000382{
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100383 delete cursor;
384 cursor = new Cursor(width, height, newHotspot, data);
385 cursor->crop();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000386
387 renderedCursorInvalid = true;
388
389 std::list<VNCSConnectionST*>::iterator ci, ci_next;
390 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
391 ci_next = ci; ci_next++;
392 (*ci)->renderedCursorChange();
393 (*ci)->setCursorOrClose();
394 }
395}
396
397void VNCServerST::setCursorPos(const Point& pos)
398{
399 if (!cursorPos.equals(pos)) {
400 cursorPos = pos;
401 renderedCursorInvalid = true;
402 std::list<VNCSConnectionST*>::iterator ci;
403 for (ci = clients.begin(); ci != clients.end(); ci++)
404 (*ci)->renderedCursorChange();
405 }
406}
407
Pierre Ossmanbb305ca2016-12-11 12:41:26 +0100408void VNCServerST::setLEDState(unsigned int state)
409{
Pierre Ossmanb45a84f2016-12-12 16:59:15 +0100410 std::list<VNCSConnectionST*>::iterator ci, ci_next;
411
412 if (state == ledState)
413 return;
414
Pierre Ossmanbb305ca2016-12-11 12:41:26 +0100415 ledState = state;
Pierre Ossmanb45a84f2016-12-12 16:59:15 +0100416
417 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
418 ci_next = ci; ci_next++;
419 (*ci)->setLEDStateOrClose(state);
420 }
Pierre Ossmanbb305ca2016-12-11 12:41:26 +0100421}
422
Pierre Ossmanb6843412018-10-05 17:30:52 +0200423// Event handlers
424
425void VNCServerST::keyEvent(rdr::U32 keysym, rdr::U32 keycode, bool down)
426{
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200427 if (rfb::Server::maxIdleTime)
428 idleTimer.start(secsToMillis(rfb::Server::maxIdleTime));
Pierre Ossmanb6843412018-10-05 17:30:52 +0200429
430 // Remap the key if required
431 if (keyRemapper) {
432 rdr::U32 newkey;
433 newkey = keyRemapper->remapKey(keysym);
434 if (newkey != keysym) {
435 slog.debug("Key remapped to 0x%x", newkey);
436 keysym = newkey;
437 }
438 }
439
440 desktop->keyEvent(keysym, keycode, down);
441}
442
443void VNCServerST::pointerEvent(VNCSConnectionST* client,
444 const Point& pos, int buttonMask)
445{
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200446 if (rfb::Server::maxIdleTime)
447 idleTimer.start(secsToMillis(rfb::Server::maxIdleTime));
Pierre Ossmanb6843412018-10-05 17:30:52 +0200448
449 // Let one client own the cursor whilst buttons are pressed in order
450 // to provide a bit more sane user experience
451 if ((pointerClient != NULL) && (pointerClient != client))
452 return;
453
454 if (buttonMask)
455 pointerClient = client;
456 else
457 pointerClient = NULL;
458
459 desktop->pointerEvent(pos, buttonMask);
460}
461
462void VNCServerST::clientCutText(const char* str, int len)
463{
464 desktop->clientCutText(str, len);
465}
466
Pierre Ossman07e44cc2018-10-05 17:32:57 +0200467unsigned int VNCServerST::setDesktopSize(VNCSConnectionST* requester,
468 int fb_width, int fb_height,
469 const ScreenSet& layout)
470{
471 unsigned int result;
472 std::list<VNCSConnectionST*>::iterator ci, ci_next;
473
474 // Don't bother the desktop with an invalid configuration
475 if (!layout.validate(fb_width, fb_height))
476 return resultInvalid;
477
478 // FIXME: the desktop will call back to VNCServerST and an extra set
479 // of ExtendedDesktopSize messages will be sent. This is okay
480 // protocol-wise, but unnecessary.
481 result = desktop->setScreenLayout(fb_width, fb_height, layout);
482 if (result != resultSuccess)
483 return result;
484
485 // Sanity check
486 if (screenLayout != layout)
487 throw Exception("Desktop configured a different screen layout than requested");
488
489 // Notify other clients
490 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
491 ci_next = ci; ci_next++;
492 if ((*ci) == requester)
493 continue;
494 (*ci)->screenLayoutChangeOrClose(reasonOtherClient);
495 }
496
497 return resultSuccess;
498}
499
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000500// Other public methods
501
502void VNCServerST::approveConnection(network::Socket* sock, bool accept,
503 const char* reason)
504{
505 std::list<VNCSConnectionST*>::iterator ci;
506 for (ci = clients.begin(); ci != clients.end(); ci++) {
507 if ((*ci)->getSock() == sock) {
508 (*ci)->approveConnectionOrClose(accept, reason);
509 return;
510 }
511 }
512}
513
514void VNCServerST::closeClients(const char* reason, network::Socket* except)
515{
516 std::list<VNCSConnectionST*>::iterator i, next_i;
517 for (i=clients.begin(); i!=clients.end(); i=next_i) {
518 next_i = i; next_i++;
519 if ((*i)->getSock() != except)
520 (*i)->close(reason);
521 }
522}
523
524void VNCServerST::getSockets(std::list<network::Socket*>* sockets)
525{
526 sockets->clear();
527 std::list<VNCSConnectionST*>::iterator ci;
528 for (ci = clients.begin(); ci != clients.end(); ci++) {
529 sockets->push_back((*ci)->getSock());
530 }
531 std::list<network::Socket*>::iterator si;
532 for (si = closingSockets.begin(); si != closingSockets.end(); si++) {
533 sockets->push_back(*si);
534 }
535}
536
Pierre Ossman7d64b332018-10-08 15:59:02 +0200537SConnection* VNCServerST::getConnection(network::Socket* sock) {
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000538 std::list<VNCSConnectionST*>::iterator ci;
539 for (ci = clients.begin(); ci != clients.end(); ci++) {
540 if ((*ci)->getSock() == sock)
541 return *ci;
542 }
543 return 0;
544}
545
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000546bool VNCServerST::handleTimeout(Timer* t)
547{
Pierre Ossman6e49e952016-10-07 15:59:38 +0200548 if (t == &frameTimer) {
549 // We keep running until we go a full interval without any updates
550 if (comparer->is_empty())
551 return false;
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000552
Pierre Ossman6e49e952016-10-07 15:59:38 +0200553 writeUpdate();
Pierre Ossman7be73d72017-11-06 13:16:35 +0100554
555 // If this is the first iteration then we need to adjust the timeout
556 if (frameTimer.getTimeoutMs() != 1000/rfb::Server::frameRate) {
557 frameTimer.start(1000/rfb::Server::frameRate);
558 return false;
559 }
560
Pierre Ossman6e49e952016-10-07 15:59:38 +0200561 return true;
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200562 } else if (t == &idleTimer) {
563 slog.info("MaxIdleTime reached, exiting");
Pierre Ossman10688ef2018-09-29 11:24:19 +0200564 desktop->terminate();
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200565 } else if (t == &disconnectTimer) {
566 slog.info("MaxDisconnectionTime reached, exiting");
Pierre Ossman10688ef2018-09-29 11:24:19 +0200567 desktop->terminate();
Pierre Ossmanf43137c2018-10-26 15:34:03 +0200568 } else if (t == &connectTimer) {
569 slog.info("MaxConnectionTime reached, exiting");
Pierre Ossman10688ef2018-09-29 11:24:19 +0200570 desktop->terminate();
Pierre Ossman6e49e952016-10-07 15:59:38 +0200571 }
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000572
573 return false;
574}
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000575
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200576void VNCServerST::queryConnection(VNCSConnectionST* client,
Pierre Ossmaneef6c9a2018-10-05 17:11:25 +0200577 const char* userName)
578{
Pierre Ossman6c97fa42018-10-05 17:35:51 +0200579 // - Authentication succeeded - clear from blacklist
580 CharArray name;
581 name.buf = client->getSock()->getPeerAddress();
582 blHosts->clearBlackmark(name.buf);
583
584 // - Prepare the desktop for that the client will start requiring
585 // resources after this
586 startDesktop();
587
588 // - Special case to provide a more useful error message
589 if (rfb::Server::neverShared &&
590 !rfb::Server::disconnectClients &&
591 authClientCount() > 0) {
592 approveConnection(client->getSock(), false,
593 "The server is already in use");
594 return;
595 }
596
597 // - Are we configured to do queries?
598 if (!rfb::Server::queryConnect &&
599 !client->getSock()->requiresQuery()) {
600 approveConnection(client->getSock(), true, NULL);
601 return;
602 }
603
604 // - Does the client have the right to bypass the query?
605 if (client->accessCheck(SConnection::AccessNoQuery))
606 {
607 approveConnection(client->getSock(), true, NULL);
608 return;
609 }
610
611 desktop->queryConnection(client->getSock(), userName);
612}
613
614void VNCServerST::clientReady(VNCSConnectionST* client, bool shared)
615{
616 if (!shared) {
617 if (rfb::Server::disconnectClients &&
618 client->accessCheck(SConnection::AccessNonShared)) {
619 // - Close all the other connected clients
620 slog.debug("non-shared connection - closing clients");
621 closeClients("Non-shared connection requested", client->getSock());
622 } else {
623 // - Refuse this connection if there are existing clients, in addition to
624 // this one
625 if (authClientCount() > 1) {
626 client->close("Server is already in use");
627 return;
628 }
629 }
630 }
Pierre Ossmaneef6c9a2018-10-05 17:11:25 +0200631}
632
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000633// -=- Internal methods
634
635void VNCServerST::startDesktop()
636{
637 if (!desktopStarted) {
638 slog.debug("starting desktop");
639 desktop->start(this);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000640 if (!pb)
641 throw Exception("SDesktop::start() did not set a valid PixelBuffer");
Pierre Ossman6cd61172018-05-07 14:24:56 +0200642 desktopStarted = true;
643 // The tracker might have accumulated changes whilst we were
644 // stopped, so flush those out
645 if (!comparer->is_empty())
646 writeUpdate();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000647 }
648}
649
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +0100650void VNCServerST::stopDesktop()
651{
652 if (desktopStarted) {
653 slog.debug("stopping desktop");
654 desktopStarted = false;
655 desktop->stop();
656 stopFrameClock();
657 }
658}
659
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000660int VNCServerST::authClientCount() {
661 int count = 0;
662 std::list<VNCSConnectionST*>::iterator ci;
663 for (ci = clients.begin(); ci != clients.end(); ci++) {
664 if ((*ci)->authenticated())
665 count++;
666 }
667 return count;
668}
669
670inline bool VNCServerST::needRenderedCursor()
671{
672 std::list<VNCSConnectionST*>::iterator ci;
673 for (ci = clients.begin(); ci != clients.end(); ci++)
674 if ((*ci)->needRenderedCursor()) return true;
675 return false;
676}
677
Pierre Ossman6e49e952016-10-07 15:59:38 +0200678void VNCServerST::startFrameClock()
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000679{
Pierre Ossman6e49e952016-10-07 15:59:38 +0200680 if (frameTimer.isStarted())
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000681 return;
Pierre Ossman559a2e82012-01-23 15:54:11 +0000682 if (blockCounter > 0)
683 return;
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +0100684 if (!desktopStarted)
685 return;
Pierre Ossman559a2e82012-01-23 15:54:11 +0000686
Pierre Ossman7be73d72017-11-06 13:16:35 +0100687 // The first iteration will be just half a frame as we get a very
688 // unstable update rate if we happen to be perfectly in sync with
689 // the application's update rate
690 frameTimer.start(1000/rfb::Server::frameRate/2);
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000691}
692
Pierre Ossman6e49e952016-10-07 15:59:38 +0200693void VNCServerST::stopFrameClock()
694{
695 frameTimer.stop();
696}
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000697
Pierre Ossmana2b80d62018-03-23 09:30:09 +0100698int VNCServerST::msToNextUpdate()
699{
700 // FIXME: If the application is updating slower than frameRate then
701 // we could allow the clients more time here
702
703 if (!frameTimer.isStarted())
704 return 1000/rfb::Server::frameRate/2;
705 else
706 return frameTimer.getRemainingMs();
707}
708
Pierre Ossman6e49e952016-10-07 15:59:38 +0200709// writeUpdate() is called on a regular interval in order to see what
710// updates are pending and propagates them to the update tracker for
711// each client. It uses the ComparingUpdateTracker's compare() method
712// to filter out areas of the screen which haven't actually changed. It
713// also checks the state of the (server-side) rendered cursor, if
714// necessary rendering it again with the correct background.
715
716void VNCServerST::writeUpdate()
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000717{
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000718 UpdateInfo ui;
Pierre Ossman6e49e952016-10-07 15:59:38 +0200719 Region toCheck;
720
721 std::list<VNCSConnectionST*>::iterator ci, ci_next;
722
723 assert(blockCounter == 0);
Pierre Ossmanb53c3bf2018-03-22 16:01:44 +0100724 assert(desktopStarted);
Pierre Ossman6e49e952016-10-07 15:59:38 +0200725
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000726 comparer->getUpdateInfo(&ui, pb->getRect());
Pierre Ossman6e49e952016-10-07 15:59:38 +0200727 toCheck = ui.changed.union_(ui.copied);
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000728
Pierre Ossman6e49e952016-10-07 15:59:38 +0200729 if (needRenderedCursor()) {
Pierre Ossman6a1a0d02017-02-19 15:48:17 +0100730 Rect clippedCursorRect = Rect(0, 0, cursor->width(), cursor->height())
731 .translate(cursorPos.subtract(cursor->hotspot()))
732 .intersect(pb->getRect());
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000733
Pierre Ossman24684e52016-12-05 16:58:19 +0100734 if (!toCheck.intersect(clippedCursorRect).is_empty())
735 renderedCursorInvalid = true;
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000736 }
737
738 pb->grabRegion(toCheck);
739
Pierre Ossmanb114cec2011-11-20 15:36:11 +0000740 if (getComparerState())
741 comparer->enable();
742 else
743 comparer->disable();
744
745 if (comparer->compare())
Constantin Kaplinskyf0b3be72008-08-21 05:22:04 +0000746 comparer->getUpdateInfo(&ui, pb->getRect());
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000747
Pierre Ossman6e49e952016-10-07 15:59:38 +0200748 comparer->clear();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000749
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000750 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
751 ci_next = ci; ci_next++;
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000752 (*ci)->add_copied(ui.copied, ui.copy_delta);
753 (*ci)->add_changed(ui.changed);
Pierre Ossman6e49e952016-10-07 15:59:38 +0200754 (*ci)->writeFramebufferUpdateOrClose();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000755 }
Pierre Ossman6e49e952016-10-07 15:59:38 +0200756}
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000757
Pierre Ossman6e49e952016-10-07 15:59:38 +0200758// checkUpdate() is called by clients to see if it is safe to read from
759// the framebuffer at this time.
760
Pierre Ossman8efc7b42018-03-23 11:45:51 +0100761Region VNCServerST::getPendingRegion()
Pierre Ossman6e49e952016-10-07 15:59:38 +0200762{
Pierre Ossman8efc7b42018-03-23 11:45:51 +0100763 UpdateInfo ui;
764
Pierre Ossman6e49e952016-10-07 15:59:38 +0200765 // Block clients as the frame buffer cannot be safely accessed
766 if (blockCounter > 0)
Pierre Ossman8efc7b42018-03-23 11:45:51 +0100767 return pb->getRect();
Pierre Ossman6e49e952016-10-07 15:59:38 +0200768
769 // Block client from updating if there are pending updates
Pierre Ossman8efc7b42018-03-23 11:45:51 +0100770 if (comparer->is_empty())
771 return Region();
Pierre Ossmanbbf955e2011-11-08 12:44:10 +0000772
Pierre Ossman8efc7b42018-03-23 11:45:51 +0100773 comparer->getUpdateInfo(&ui, pb->getRect());
774
775 return ui.changed.union_(ui.copied);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000776}
777
Pierre Ossman24684e52016-12-05 16:58:19 +0100778const RenderedCursor* VNCServerST::getRenderedCursor()
779{
780 if (renderedCursorInvalid) {
Pierre Ossman7cb4f312017-02-24 13:25:00 +0100781 renderedCursor.update(pb, cursor, cursorPos);
Pierre Ossman24684e52016-12-05 16:58:19 +0100782 renderedCursorInvalid = false;
783 }
784
785 return &renderedCursor;
786}
787
Pierre Ossmanb114cec2011-11-20 15:36:11 +0000788bool VNCServerST::getComparerState()
789{
790 if (rfb::Server::compareFB == 0)
791 return false;
792 if (rfb::Server::compareFB != 2)
793 return true;
794
795 std::list<VNCSConnectionST*>::iterator ci, ci_next;
796 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
797 ci_next = ci; ci_next++;
798 if ((*ci)->getComparerState())
799 return true;
800 }
801 return false;
802}