blob: d36354c873a549d03dda729ca2832a5f6e1428a4 [file] [log] [blame]
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
2 *
3 * This is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This software is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this software; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16 * USA.
17 */
18
19// -=- Single-Threaded VNC Server implementation
20
21
22// Note about how sockets get closed:
23//
24// Closing sockets to clients is non-trivial because the code which calls
25// VNCServerST must explicitly know about all the sockets (so that it can block
26// on them appropriately). However, VNCServerST may want to close clients for
27// a number of reasons, and from a variety of entry points. The simplest is
28// when processSocketEvent() is called for a client, and the remote end has
29// closed its socket. A more complex reason is when processSocketEvent() is
30// called for a client which has just sent a ClientInit with the shared flag
31// set to false - in this case we want to close all other clients. Yet another
32// reason for disconnecting clients is when the desktop size has changed as a
33// result of a call to setPixelBuffer().
34//
35// The responsibility for creating and deleting sockets is entirely with the
36// calling code. When VNCServerST wants to close a connection to a client it
37// calls the VNCSConnectionST's close() method which calls shutdown() on the
38// socket. Eventually the calling code will notice that the socket has been
39// shut down and call removeSocket() so that we can delete the
40// VNCSConnectionST. Note that the socket must not be deleted by the calling
41// code until after removeSocket() has been called.
42//
43// One minor complication is that we don't allocate a VNCSConnectionST object
44// for a blacklisted host (since we want to minimise the resources used for
45// dealing with such a connection). In order to properly implement the
46// getSockets function, we must maintain a separate closingSockets list,
47// otherwise blacklisted connections might be "forgotten".
48
49
50#include <rfb/ServerCore.h>
51#include <rfb/VNCServerST.h>
52#include <rfb/VNCSConnectionST.h>
53#include <rfb/ComparingUpdateTracker.h>
54#include <rfb/SSecurityFactoryStandard.h>
55#include <rfb/KeyRemapper.h>
56#include <rfb/util.h>
57
58#include <rdr/types.h>
59
60using namespace rfb;
61
62static LogWriter slog("VNCServerST");
63LogWriter VNCServerST::connectionsLog("Connections");
64static SSecurityFactoryStandard defaultSecurityFactory;
65
66//
67// -=- VNCServerST Implementation
68//
69
70// -=- Constructors/Destructor
71
72VNCServerST::VNCServerST(const char* name_, SDesktop* desktop_,
73 SSecurityFactory* sf)
74 : blHosts(&blacklist), desktop(desktop_), desktopStarted(false), pb(0),
75 m_pFTManager(0), name(strDup(name_)), pointerClient(0), comparer(0),
76 renderedCursorInvalid(false),
77 securityFactory(sf ? sf : &defaultSecurityFactory),
78 queryConnectionHandler(0), keyRemapper(&KeyRemapper::defInstance),
79 useEconomicTranslate(false),
Constantin Kaplinsky82328312008-04-24 08:44:24 +000080 lastConnectionTime(0), disableclients(false),
81 m_videoSelectionEnabled(false)
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +000082{
83 lastUserInputTime = lastDisconnectTime = time(0);
84 slog.debug("creating single-threaded server %s", name.buf);
85}
86
87VNCServerST::~VNCServerST()
88{
89 slog.debug("shutting down server %s", name.buf);
90
91 // Close any active clients, with appropriate logging & cleanup
92 closeClients("Server shutdown");
93
94 // Delete all the clients, and their sockets, and any closing sockets
95 // NB: Deleting a client implicitly removes it from the clients list
96 while (!clients.empty()) {
97 delete clients.front();
98 }
99
100 // Stop the desktop object if active, *only* after deleting all clients!
101 if (desktopStarted) {
102 desktopStarted = false;
103 desktop->stop();
104 }
105
106 delete comparer;
107}
108
109
110// SocketServer methods
111
112void VNCServerST::addSocket(network::Socket* sock, bool outgoing)
113{
114 // - Check the connection isn't black-marked
115 // *** do this in getSecurity instead?
116 CharArray address(sock->getPeerAddress());
117 if (blHosts->isBlackmarked(address.buf)) {
118 connectionsLog.error("blacklisted: %s", address.buf);
119 try {
120 SConnection::writeConnFailedFromScratch("Too many security failures",
121 &sock->outStream());
122 } catch (rdr::Exception&) {
123 }
124 sock->shutdown();
125 closingSockets.push_back(sock);
126 return;
127 }
128
129 if (clients.empty()) {
130 lastConnectionTime = time(0);
131 }
132
133 VNCSConnectionST* client = new VNCSConnectionST(this, sock, outgoing);
134 client->init();
135}
136
137void VNCServerST::removeSocket(network::Socket* sock) {
138 // - If the socket has resources allocated to it, delete them
139 std::list<VNCSConnectionST*>::iterator ci;
140 for (ci = clients.begin(); ci != clients.end(); ci++) {
141 if ((*ci)->getSock() == sock) {
142 // - Delete the per-Socket resources
143 delete *ci;
144
145 // - Check that the desktop object is still required
146 if (authClientCount() == 0 && desktopStarted) {
147 slog.debug("no authenticated clients - stopping desktop");
148 desktopStarted = false;
149 desktop->stop();
Constantin Kaplinsky433eb1b2008-09-05 05:14:03 +0000150 setVideoRectangle(Rect(0, 0, 0, 0));
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000151 }
152 return;
153 }
154 }
155
156 // - If the Socket has no resources, it may have been a closingSocket
157 closingSockets.remove(sock);
158}
159
160void VNCServerST::processSocketEvent(network::Socket* sock)
161{
162 // - Find the appropriate VNCSConnectionST and process the event
163 std::list<VNCSConnectionST*>::iterator ci;
164 for (ci = clients.begin(); ci != clients.end(); ci++) {
165 if ((*ci)->getSock() == sock) {
166 (*ci)->processMessages();
167 return;
168 }
169 }
170 throw rdr::Exception("invalid Socket in VNCServerST");
171}
172
173int VNCServerST::checkTimeouts()
174{
175 int timeout = 0;
176 std::list<VNCSConnectionST*>::iterator ci, ci_next;
177 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
178 ci_next = ci; ci_next++;
179 soonestTimeout(&timeout, (*ci)->checkIdleTimeout());
180 }
181
182 int timeLeft;
Constantin Kaplinsky8499d0c2008-08-21 05:51:29 +0000183 time_t now = time(0);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000184
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000185 // Check MaxDisconnectionTime
186 if (rfb::Server::maxDisconnectionTime && clients.empty()) {
187 if (now < lastDisconnectTime) {
188 // Someone must have set the time backwards.
189 slog.info("Time has gone backwards - resetting lastDisconnectTime");
190 lastDisconnectTime = now;
191 }
192 timeLeft = lastDisconnectTime + rfb::Server::maxDisconnectionTime - now;
193 if (timeLeft < -60) {
194 // Someone must have set the time forwards.
195 slog.info("Time has gone forwards - resetting lastDisconnectTime");
196 lastDisconnectTime = now;
197 timeLeft = rfb::Server::maxDisconnectionTime;
198 }
199 if (timeLeft <= 0) {
200 slog.info("MaxDisconnectionTime reached, exiting");
201 exit(0);
202 }
203 soonestTimeout(&timeout, timeLeft * 1000);
204 }
205
206 // Check MaxConnectionTime
207 if (rfb::Server::maxConnectionTime && lastConnectionTime && !clients.empty()) {
208 if (now < lastConnectionTime) {
209 // Someone must have set the time backwards.
210 slog.info("Time has gone backwards - resetting lastConnectionTime");
211 lastConnectionTime = now;
212 }
213 timeLeft = lastConnectionTime + rfb::Server::maxConnectionTime - now;
214 if (timeLeft < -60) {
215 // Someone must have set the time forwards.
216 slog.info("Time has gone forwards - resetting lastConnectionTime");
217 lastConnectionTime = now;
218 timeLeft = rfb::Server::maxConnectionTime;
219 }
220 if (timeLeft <= 0) {
221 slog.info("MaxConnectionTime reached, exiting");
222 exit(0);
223 }
224 soonestTimeout(&timeout, timeLeft * 1000);
225 }
226
227
228 // Check MaxIdleTime
229 if (rfb::Server::maxIdleTime) {
230 if (now < lastUserInputTime) {
231 // Someone must have set the time backwards.
232 slog.info("Time has gone backwards - resetting lastUserInputTime");
233 lastUserInputTime = now;
234 }
235 timeLeft = lastUserInputTime + rfb::Server::maxIdleTime - now;
236 if (timeLeft < -60) {
237 // Someone must have set the time forwards.
238 slog.info("Time has gone forwards - resetting lastUserInputTime");
239 lastUserInputTime = now;
240 timeLeft = rfb::Server::maxIdleTime;
241 }
242 if (timeLeft <= 0) {
243 slog.info("MaxIdleTime reached, exiting");
244 exit(0);
245 }
246 soonestTimeout(&timeout, timeLeft * 1000);
247 }
248
249 return timeout;
250}
251
252
253// VNCServer methods
254
255void VNCServerST::setPixelBuffer(PixelBuffer* pb_)
256{
257 pb = pb_;
258 delete comparer;
259 comparer = 0;
260
261 if (pb) {
262 comparer = new ComparingUpdateTracker(pb);
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000263 applyVideoRectangle();
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000264 cursor.setPF(pb->getPF());
265 renderedCursor.setPF(pb->getPF());
266
267 std::list<VNCSConnectionST*>::iterator ci, ci_next;
268 for (ci=clients.begin();ci!=clients.end();ci=ci_next) {
269 ci_next = ci; ci_next++;
270 (*ci)->pixelBufferChange();
271 }
272 } else {
273 if (desktopStarted)
274 throw Exception("setPixelBuffer: null PixelBuffer when desktopStarted?");
275 }
276}
277
278void VNCServerST::setColourMapEntries(int firstColour, int nColours)
279{
280 std::list<VNCSConnectionST*>::iterator ci, ci_next;
281 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
282 ci_next = ci; ci_next++;
283 (*ci)->setColourMapEntriesOrClose(firstColour, nColours);
284 }
285}
286
287void VNCServerST::bell()
288{
289 std::list<VNCSConnectionST*>::iterator ci, ci_next;
290 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
291 ci_next = ci; ci_next++;
292 (*ci)->bell();
293 }
294}
295
296void VNCServerST::serverCutText(const char* str, int len)
297{
298 std::list<VNCSConnectionST*>::iterator ci, ci_next;
299 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
300 ci_next = ci; ci_next++;
301 (*ci)->serverCutText(str, len);
302 }
303}
304
Peter Ã…strandc39e0782009-01-15 12:21:42 +0000305void VNCServerST::setName(const char* name_)
306{
307 name.replaceBuf(strDup(name_));
308 std::list<VNCSConnectionST*>::iterator ci, ci_next;
309 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
310 ci_next = ci; ci_next++;
311 (*ci)->setDesktopName(name_);
312 }
313}
314
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000315void VNCServerST::add_changed(const Region& region)
316{
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000317 if (comparer != 0) {
318 comparer->add_changed(region);
319 }
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000320}
321
322void VNCServerST::add_copied(const Region& dest, const Point& delta)
323{
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000324 if (comparer != 0) {
325 comparer->add_copied(dest, delta);
326 }
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000327}
328
Constantin Kaplinsky1a845d02007-08-31 21:06:53 +0000329void VNCServerST::set_video_area(const Rect &rect)
330{
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000331 if (comparer != 0) {
332 comparer->set_video_area(rect);
333 }
Constantin Kaplinsky1a845d02007-08-31 21:06:53 +0000334}
335
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000336bool VNCServerST::clientsReadyForUpdate()
337{
338 std::list<VNCSConnectionST*>::iterator ci;
339 for (ci = clients.begin(); ci != clients.end(); ci++) {
340 if ((*ci)->readyForUpdate())
341 return true;
342 }
343 return false;
344}
345
346void VNCServerST::tryUpdate()
347{
348 std::list<VNCSConnectionST*>::iterator ci, ci_next;
349 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
350 ci_next = ci; ci_next++;
351 (*ci)->writeFramebufferUpdateOrClose();
352 }
353}
354
355void VNCServerST::setCursor(int width, int height, const Point& newHotspot,
356 void* data, void* mask)
357{
358 cursor.hotspot = newHotspot;
359 cursor.setSize(width, height);
360 memcpy(cursor.data, data, cursor.dataLen());
361 memcpy(cursor.mask.buf, mask, cursor.maskLen());
362
363 cursor.crop();
364
365 renderedCursorInvalid = true;
366
367 std::list<VNCSConnectionST*>::iterator ci, ci_next;
368 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
369 ci_next = ci; ci_next++;
370 (*ci)->renderedCursorChange();
371 (*ci)->setCursorOrClose();
372 }
373}
374
375void VNCServerST::setCursorPos(const Point& pos)
376{
377 if (!cursorPos.equals(pos)) {
378 cursorPos = pos;
379 renderedCursorInvalid = true;
380 std::list<VNCSConnectionST*>::iterator ci;
381 for (ci = clients.begin(); ci != clients.end(); ci++)
382 (*ci)->renderedCursorChange();
383 }
384}
385
386// Other public methods
387
388void VNCServerST::approveConnection(network::Socket* sock, bool accept,
389 const char* reason)
390{
391 std::list<VNCSConnectionST*>::iterator ci;
392 for (ci = clients.begin(); ci != clients.end(); ci++) {
393 if ((*ci)->getSock() == sock) {
394 (*ci)->approveConnectionOrClose(accept, reason);
395 return;
396 }
397 }
398}
399
400void VNCServerST::closeClients(const char* reason, network::Socket* except)
401{
402 std::list<VNCSConnectionST*>::iterator i, next_i;
403 for (i=clients.begin(); i!=clients.end(); i=next_i) {
404 next_i = i; next_i++;
405 if ((*i)->getSock() != except)
406 (*i)->close(reason);
407 }
408}
409
410void VNCServerST::getSockets(std::list<network::Socket*>* sockets)
411{
412 sockets->clear();
413 std::list<VNCSConnectionST*>::iterator ci;
414 for (ci = clients.begin(); ci != clients.end(); ci++) {
415 sockets->push_back((*ci)->getSock());
416 }
417 std::list<network::Socket*>::iterator si;
418 for (si = closingSockets.begin(); si != closingSockets.end(); si++) {
419 sockets->push_back(*si);
420 }
421}
422
423SConnection* VNCServerST::getSConnection(network::Socket* sock) {
424 std::list<VNCSConnectionST*>::iterator ci;
425 for (ci = clients.begin(); ci != clients.end(); ci++) {
426 if ((*ci)->getSock() == sock)
427 return *ci;
428 }
429 return 0;
430}
431
432
433// -=- Internal methods
434
435void VNCServerST::startDesktop()
436{
437 if (!desktopStarted) {
438 slog.debug("starting desktop");
439 desktop->start(this);
440 desktopStarted = true;
441 if (!pb)
442 throw Exception("SDesktop::start() did not set a valid PixelBuffer");
443 }
444}
445
446int VNCServerST::authClientCount() {
447 int count = 0;
448 std::list<VNCSConnectionST*>::iterator ci;
449 for (ci = clients.begin(); ci != clients.end(); ci++) {
450 if ((*ci)->authenticated())
451 count++;
452 }
453 return count;
454}
455
456inline bool VNCServerST::needRenderedCursor()
457{
458 std::list<VNCSConnectionST*>::iterator ci;
459 for (ci = clients.begin(); ci != clients.end(); ci++)
460 if ((*ci)->needRenderedCursor()) return true;
461 return false;
462}
463
464// checkUpdate() is called just before sending an update. It checks to see
465// what updates are pending and propagates them to the update tracker for each
466// client. It uses the ComparingUpdateTracker's compare() method to filter out
467// areas of the screen which haven't actually changed. It also checks the
468// state of the (server-side) rendered cursor, if necessary rendering it again
469// with the correct background.
470
471void VNCServerST::checkUpdate()
472{
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000473 UpdateInfo ui;
474 comparer->getUpdateInfo(&ui, pb->getRect());
475
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000476 bool renderCursor = needRenderedCursor();
477
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000478 if (ui.is_empty() && !(renderCursor && renderedCursorInvalid))
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000479 return;
480
Constantin Kaplinsky1a845d02007-08-31 21:06:53 +0000481 Region toCheck = ui.changed.union_(ui.copied).union_(ui.video_area);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000482
483 if (renderCursor) {
484 Rect clippedCursorRect
485 = cursor.getRect(cursorTL()).intersect(pb->getRect());
486
487 if (!renderedCursorInvalid && (toCheck.intersect(clippedCursorRect)
488 .is_empty())) {
489 renderCursor = false;
490 } else {
491 renderedCursorTL = clippedCursorRect.tl;
492 renderedCursor.setSize(clippedCursorRect.width(),
493 clippedCursorRect.height());
494 toCheck.assign_union(clippedCursorRect);
495 }
496 }
497
498 pb->grabRegion(toCheck);
499
Constantin Kaplinskyf0b3be72008-08-21 05:22:04 +0000500 if (rfb::Server::compareFB) {
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000501 comparer->compare();
Constantin Kaplinskyf0b3be72008-08-21 05:22:04 +0000502 comparer->getUpdateInfo(&ui, pb->getRect());
503 }
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000504
505 if (renderCursor) {
506 pb->getImage(renderedCursor.data,
507 renderedCursor.getRect(renderedCursorTL));
508 renderedCursor.maskRect(cursor.getRect(cursorTL()
509 .subtract(renderedCursorTL)),
510 cursor.data, cursor.mask.buf);
511 renderedCursorInvalid = false;
512 }
513
514 std::list<VNCSConnectionST*>::iterator ci, ci_next;
515 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
516 ci_next = ci; ci_next++;
Constantin Kaplinsky604d7812007-08-31 15:50:37 +0000517 (*ci)->add_copied(ui.copied, ui.copy_delta);
518 (*ci)->add_changed(ui.changed);
Constantin Kaplinsky1a845d02007-08-31 21:06:53 +0000519 (*ci)->set_video_area(ui.video_area);
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000520 }
521
522 comparer->clear();
523}
524
Constantin Kaplinsky6970b2d2008-06-13 18:07:53 +0000525void VNCServerST::checkVideoUpdate()
526{
527 const Rect &videoRect = comparer->getVideoArea();
528 Region videoRegion(videoRect);
529
530 if (!videoRegion.is_empty()) {
531 pb->grabRegion(videoRegion);
532
533 std::list<VNCSConnectionST*>::iterator ci, ci_next;
534 for (ci = clients.begin(); ci != clients.end(); ci = ci_next) {
535 ci_next = ci; ci_next++;
536 (*ci)->set_video_area(videoRect);
537 }
538 }
539}
540
Constantin Kaplinskya2adc8d2006-05-25 05:01:55 +0000541void VNCServerST::getConnInfo(ListConnInfo * listConn)
542{
543 listConn->Clear();
544 listConn->setDisable(getDisable());
545 if (clients.empty())
546 return;
547 std::list<VNCSConnectionST*>::iterator i;
548 for (i = clients.begin(); i != clients.end(); i++)
549 listConn->addInfo((void*)(*i), (*i)->getSock()->getPeerAddress(),
550 (*i)->getStartTime(), (*i)->getStatus());
551}
552
553void VNCServerST::setConnStatus(ListConnInfo* listConn)
554{
555 setDisable(listConn->getDisable());
556 if (listConn->Empty() || clients.empty()) return;
557 for (listConn->iBegin(); !listConn->iEnd(); listConn->iNext()) {
558 VNCSConnectionST* conn = (VNCSConnectionST*)listConn->iGetConn();
559 std::list<VNCSConnectionST*>::iterator i;
560 for (i = clients.begin(); i != clients.end(); i++) {
561 if ((*i) == conn) {
562 int status = listConn->iGetStatus();
563 if (status == 3) {
564 (*i)->close(0);
565 } else {
566 (*i)->setStatus(status);
567 }
568 break;
569 }
570 }
571 }
572}
Constantin Kaplinsky9d1fc6c2008-06-14 05:23:10 +0000573
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000574void VNCServerST::enableVideoSelection(bool enable)
575{
576 slog.debug("Enabling video selection");
577 m_videoSelectionEnabled = enable;
578 applyVideoRectangle();
579}
580
581bool VNCServerST::isVideoSelectionEnabled() const
582{
583 return m_videoSelectionEnabled;
584}
585
Constantin Kaplinsky9d1fc6c2008-06-14 05:23:10 +0000586void VNCServerST::setVideoRectangle(const Rect& r)
587{
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000588 m_videoRect = r;
589 applyVideoRectangle();
Constantin Kaplinsky9d1fc6c2008-06-14 05:23:10 +0000590}
591
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000592void VNCServerST::setDefaultVideoRectangle(const Rect& r)
Constantin Kaplinskyc341ac62008-08-21 03:35:08 +0000593{
594 m_defaultVideoRect = r;
Constantin Kaplinsky3ce6a722008-09-05 02:26:35 +0000595 applyVideoRectangle();
596}
597
598void VNCServerST::applyVideoRectangle()
599{
600 if (pb != 0) {
601 if (isVideoSelectionEnabled() && !m_videoRect.is_empty()) {
602 slog.debug("Applying video selection");
603 set_video_area(m_videoRect);
604 } else {
605 if (!m_defaultVideoRect.is_empty()) {
606 slog.debug("Applying default video area");
607 } else {
608 slog.debug("Applying empty video area");
609 }
610 set_video_area(m_defaultVideoRect);
611 }
Constantin Kaplinsky53bdd3f2008-08-21 04:10:58 +0000612 }
Constantin Kaplinskyc341ac62008-08-21 03:35:08 +0000613}