You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

CConn.cxx 18KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690
  1. /* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
  2. * Copyright (C) 2011 D. R. Commander. All Rights Reserved.
  3. * Copyright 2009-2014 Pierre Ossman for Cendio AB
  4. *
  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. #ifdef HAVE_CONFIG_H
  21. #include <config.h>
  22. #endif
  23. #include <assert.h>
  24. #ifndef _WIN32
  25. #include <unistd.h>
  26. #endif
  27. #include <rfb/CMsgWriter.h>
  28. #include <rfb/encodings.h>
  29. #include <rfb/Decoder.h>
  30. #include <rfb/Hostname.h>
  31. #include <rfb/LogWriter.h>
  32. #include <rfb/util.h>
  33. #include <rfb/screenTypes.h>
  34. #include <rfb/fenceTypes.h>
  35. #include <rfb/Timer.h>
  36. #include <rdr/MemInStream.h>
  37. #include <rdr/MemOutStream.h>
  38. #include <network/TcpSocket.h>
  39. #include <FL/Fl.H>
  40. #include <FL/fl_ask.H>
  41. #include "CConn.h"
  42. #include "OptionsDialog.h"
  43. #include "DesktopWindow.h"
  44. #include "i18n.h"
  45. #include "parameters.h"
  46. #include "vncviewer.h"
  47. #ifdef WIN32
  48. #include "win32.h"
  49. #endif
  50. using namespace rdr;
  51. using namespace rfb;
  52. using namespace std;
  53. static rfb::LogWriter vlog("CConn");
  54. // 8 colours (1 bit per component)
  55. static const PixelFormat verylowColourPF(8, 3,false, true,
  56. 1, 1, 1, 2, 1, 0);
  57. // 64 colours (2 bits per component)
  58. static const PixelFormat lowColourPF(8, 6, false, true,
  59. 3, 3, 3, 4, 2, 0);
  60. // 256 colours (2-3 bits per component)
  61. static const PixelFormat mediumColourPF(8, 8, false, true,
  62. 7, 7, 3, 5, 2, 0);
  63. CConn::CConn(const char* vncServerName, network::Socket* socket=NULL)
  64. : serverHost(0), serverPort(0), desktop(NULL),
  65. pendingPFChange(false),
  66. currentEncoding(encodingTight), lastServerEncoding((unsigned int)-1),
  67. formatChange(false), encodingChange(false),
  68. firstUpdate(true), pendingUpdate(false), continuousUpdates(false),
  69. forceNonincremental(true), supportsSyncFence(false)
  70. {
  71. setShared(::shared);
  72. sock = socket;
  73. memset(decoders, 0, sizeof(decoders));
  74. int encNum = encodingNum(preferredEncoding);
  75. if (encNum != -1)
  76. currentEncoding = encNum;
  77. cp.supportsLocalCursor = true;
  78. cp.supportsDesktopResize = true;
  79. cp.supportsExtendedDesktopSize = true;
  80. cp.supportsDesktopRename = true;
  81. if (customCompressLevel)
  82. cp.compressLevel = compressLevel;
  83. else
  84. cp.compressLevel = -1;
  85. if (!noJpeg)
  86. cp.qualityLevel = qualityLevel;
  87. else
  88. cp.qualityLevel = -1;
  89. if(sock == NULL) {
  90. try {
  91. getHostAndPort(vncServerName, &serverHost, &serverPort);
  92. sock = new network::TcpSocket(serverHost, serverPort);
  93. vlog.info(_("connected to host %s port %d"), serverHost, serverPort);
  94. } catch (rdr::Exception& e) {
  95. vlog.error("%s", e.str());
  96. fl_alert("%s", e.str());
  97. exit_vncviewer();
  98. return;
  99. }
  100. }
  101. Fl::add_fd(sock->getFd(), FL_READ | FL_EXCEPT, socketEvent, this);
  102. // See callback below
  103. sock->inStream().setBlockCallback(this);
  104. setServerName(serverHost);
  105. setStreams(&sock->inStream(), &sock->outStream());
  106. initialiseProtocol();
  107. OptionsDialog::addCallback(handleOptions, this);
  108. }
  109. CConn::~CConn()
  110. {
  111. OptionsDialog::removeCallback(handleOptions);
  112. for (int i = 0; i < sizeof(decoders)/sizeof(decoders[0]); i++)
  113. delete decoders[i];
  114. if (desktop)
  115. delete desktop;
  116. delete [] serverHost;
  117. if (sock)
  118. Fl::remove_fd(sock->getFd());
  119. delete sock;
  120. }
  121. void CConn::refreshFramebuffer()
  122. {
  123. forceNonincremental = true;
  124. // Without fences, we cannot safely trigger an update request directly
  125. // but must wait for the next update to arrive.
  126. if (supportsSyncFence)
  127. requestNewUpdate();
  128. }
  129. const char *CConn::connectionInfo()
  130. {
  131. static char infoText[1024] = "";
  132. char scratch[100];
  133. char pfStr[100];
  134. // Crude way of avoiding constant overflow checks
  135. assert((sizeof(scratch) + 1) * 10 < sizeof(infoText));
  136. infoText[0] = '\0';
  137. snprintf(scratch, sizeof(scratch),
  138. _("Desktop name: %.80s"), cp.name());
  139. strcat(infoText, scratch);
  140. strcat(infoText, "\n");
  141. snprintf(scratch, sizeof(scratch),
  142. _("Host: %.80s port: %d"), serverHost, serverPort);
  143. strcat(infoText, scratch);
  144. strcat(infoText, "\n");
  145. snprintf(scratch, sizeof(scratch),
  146. _("Size: %d x %d"), cp.width, cp.height);
  147. strcat(infoText, scratch);
  148. strcat(infoText, "\n");
  149. cp.pf().print(pfStr, 100);
  150. snprintf(scratch, sizeof(scratch),
  151. _("Pixel format: %s"), pfStr);
  152. strcat(infoText, scratch);
  153. strcat(infoText, "\n");
  154. serverPF.print(pfStr, 100);
  155. snprintf(scratch, sizeof(scratch),
  156. _("(server default %s)"), pfStr);
  157. strcat(infoText, scratch);
  158. strcat(infoText, "\n");
  159. snprintf(scratch, sizeof(scratch),
  160. _("Requested encoding: %s"), encodingName(currentEncoding));
  161. strcat(infoText, scratch);
  162. strcat(infoText, "\n");
  163. snprintf(scratch, sizeof(scratch),
  164. _("Last used encoding: %s"), encodingName(lastServerEncoding));
  165. strcat(infoText, scratch);
  166. strcat(infoText, "\n");
  167. snprintf(scratch, sizeof(scratch),
  168. _("Line speed estimate: %d kbit/s"), sock->inStream().kbitsPerSecond());
  169. strcat(infoText, scratch);
  170. strcat(infoText, "\n");
  171. snprintf(scratch, sizeof(scratch),
  172. _("Protocol version: %d.%d"), cp.majorVersion, cp.minorVersion);
  173. strcat(infoText, scratch);
  174. strcat(infoText, "\n");
  175. snprintf(scratch, sizeof(scratch),
  176. _("Security method: %s"), secTypeName(csecurity->getType()));
  177. strcat(infoText, scratch);
  178. strcat(infoText, "\n");
  179. return infoText;
  180. }
  181. // The RFB core is not properly asynchronous, so it calls this callback
  182. // whenever it needs to block to wait for more data. Since FLTK is
  183. // monitoring the socket, we just make sure FLTK gets to run.
  184. void CConn::blockCallback()
  185. {
  186. int next_timer;
  187. next_timer = Timer::checkTimeouts();
  188. if (next_timer == 0)
  189. next_timer = INT_MAX;
  190. Fl::wait((double)next_timer / 1000.0);
  191. }
  192. void CConn::socketEvent(FL_SOCKET fd, void *data)
  193. {
  194. CConn *cc;
  195. static bool recursing = false;
  196. assert(data);
  197. cc = (CConn*)data;
  198. // I don't think processMsg() is recursion safe, so add this check
  199. if (recursing)
  200. return;
  201. recursing = true;
  202. try {
  203. // processMsg() only processes one message, so we need to loop
  204. // until the buffers are empty or things will stall.
  205. do {
  206. cc->processMsg();
  207. } while (cc->sock->inStream().checkNoWait(1));
  208. } catch (rdr::EndOfStream& e) {
  209. vlog.info("%s", e.str());
  210. exit_vncviewer();
  211. } catch (rdr::Exception& e) {
  212. vlog.error("%s", e.str());
  213. exit_vncviewer(e.str());
  214. }
  215. recursing = false;
  216. }
  217. ////////////////////// CConnection callback methods //////////////////////
  218. // serverInit() is called when the serverInit message has been received. At
  219. // this point we create the desktop window and display it. We also tell the
  220. // server the pixel format and encodings to use and request the first update.
  221. void CConn::serverInit()
  222. {
  223. CConnection::serverInit();
  224. // If using AutoSelect with old servers, start in FullColor
  225. // mode. See comment in autoSelectFormatAndEncoding.
  226. if (cp.beforeVersion(3, 8) && autoSelect)
  227. fullColour.setParam(true);
  228. serverPF = cp.pf();
  229. desktop = new DesktopWindow(cp.width, cp.height, cp.name(), serverPF, this);
  230. fullColourPF = desktop->getPreferredPF();
  231. // Force a switch to the format and encoding we'd like
  232. formatChange = encodingChange = true;
  233. // And kick off the update cycle
  234. requestNewUpdate();
  235. // This initial update request is a bit of a corner case, so we need
  236. // to help out setting the correct format here.
  237. assert(pendingPFChange);
  238. cp.setPF(pendingPF);
  239. pendingPFChange = false;
  240. }
  241. // setDesktopSize() is called when the desktop size changes (including when
  242. // it is set initially).
  243. void CConn::setDesktopSize(int w, int h)
  244. {
  245. CConnection::setDesktopSize(w,h);
  246. resizeFramebuffer();
  247. }
  248. // setExtendedDesktopSize() is a more advanced version of setDesktopSize()
  249. void CConn::setExtendedDesktopSize(int reason, int result, int w, int h,
  250. const rfb::ScreenSet& layout)
  251. {
  252. CConnection::setExtendedDesktopSize(reason, result, w, h, layout);
  253. if ((reason == reasonClient) && (result != resultSuccess)) {
  254. vlog.error(_("SetDesktopSize failed: %d"), result);
  255. return;
  256. }
  257. resizeFramebuffer();
  258. }
  259. // setName() is called when the desktop name changes
  260. void CConn::setName(const char* name)
  261. {
  262. CConnection::setName(name);
  263. if (desktop)
  264. desktop->setName(name);
  265. }
  266. // framebufferUpdateStart() is called at the beginning of an update.
  267. // Here we try to send out a new framebuffer update request so that the
  268. // next update can be sent out in parallel with us decoding the current
  269. // one.
  270. void CConn::framebufferUpdateStart()
  271. {
  272. // Note: This might not be true if sync fences are supported
  273. pendingUpdate = false;
  274. requestNewUpdate();
  275. }
  276. // framebufferUpdateEnd() is called at the end of an update.
  277. // For each rectangle, the FdInStream will have timed the speed
  278. // of the connection, allowing us to select format and encoding
  279. // appropriately, and then request another incremental update.
  280. void CConn::framebufferUpdateEnd()
  281. {
  282. desktop->updateWindow();
  283. if (firstUpdate) {
  284. // We need fences to make extra update requests and continuous
  285. // updates "safe". See fence() for the next step.
  286. if (cp.supportsFence)
  287. writer()->writeFence(fenceFlagRequest | fenceFlagSyncNext, 0, NULL);
  288. firstUpdate = false;
  289. }
  290. // A format change has been scheduled and we are now past the update
  291. // with the old format. Time to active the new one.
  292. if (pendingPFChange) {
  293. cp.setPF(pendingPF);
  294. pendingPFChange = false;
  295. }
  296. // Compute new settings based on updated bandwidth values
  297. if (autoSelect)
  298. autoSelectFormatAndEncoding();
  299. // Make sure that the FLTK handling and the timers gets some CPU time
  300. // in case of back to back framebuffer updates.
  301. Fl::check();
  302. Timer::checkTimeouts();
  303. }
  304. // The rest of the callbacks are fairly self-explanatory...
  305. void CConn::setColourMapEntries(int firstColour, int nColours, rdr::U16* rgbs)
  306. {
  307. vlog.error(_("Invalid SetColourMapEntries from server!"));
  308. }
  309. void CConn::bell()
  310. {
  311. fl_beep();
  312. }
  313. void CConn::serverCutText(const char* str, rdr::U32 len)
  314. {
  315. char *buffer;
  316. int size, ret;
  317. if (!acceptClipboard)
  318. return;
  319. size = fl_utf8froma(NULL, 0, str, len);
  320. if (size <= 0)
  321. return;
  322. size++;
  323. buffer = new char[size];
  324. ret = fl_utf8froma(buffer, size, str, len);
  325. assert(ret < size);
  326. vlog.debug("Got clipboard data (%d bytes)", strlen(buffer));
  327. // RFB doesn't have separate selection and clipboard concepts, so we
  328. // dump the data into both variants.
  329. Fl::copy(buffer, ret, 0);
  330. Fl::copy(buffer, ret, 1);
  331. delete [] buffer;
  332. }
  333. void CConn::dataRect(const Rect& r, int encoding)
  334. {
  335. sock->inStream().startTiming();
  336. if (encoding != encodingCopyRect)
  337. lastServerEncoding = encoding;
  338. if (!Decoder::supported(encoding)) {
  339. vlog.error(_("Unknown rect encoding %d"), encoding);
  340. throw Exception(_("Unknown rect encoding"));
  341. }
  342. if (!decoders[encoding]) {
  343. decoders[encoding] = Decoder::createDecoder(encoding, this);
  344. if (!decoders[encoding]) {
  345. vlog.error(_("Unknown rect encoding %d"), encoding);
  346. throw Exception(_("Unknown rect encoding"));
  347. }
  348. }
  349. decoders[encoding]->readRect(r, desktop->getFramebuffer());
  350. sock->inStream().stopTiming();
  351. }
  352. void CConn::setCursor(int width, int height, const Point& hotspot,
  353. void* data, void* mask)
  354. {
  355. desktop->setCursor(width, height, hotspot, data, mask);
  356. }
  357. void CConn::fence(rdr::U32 flags, unsigned len, const char data[])
  358. {
  359. CMsgHandler::fence(flags, len, data);
  360. if (flags & fenceFlagRequest) {
  361. // We handle everything synchronously so we trivially honor these modes
  362. flags = flags & (fenceFlagBlockBefore | fenceFlagBlockAfter);
  363. writer()->writeFence(flags, len, data);
  364. return;
  365. }
  366. if (len == 0) {
  367. // Initial probe
  368. if (flags & fenceFlagSyncNext) {
  369. supportsSyncFence = true;
  370. if (cp.supportsContinuousUpdates) {
  371. vlog.info(_("Enabling continuous updates"));
  372. continuousUpdates = true;
  373. writer()->writeEnableContinuousUpdates(true, 0, 0, cp.width, cp.height);
  374. }
  375. }
  376. } else {
  377. // Pixel format change
  378. rdr::MemInStream memStream(data, len);
  379. PixelFormat pf;
  380. pf.read(&memStream);
  381. cp.setPF(pf);
  382. }
  383. }
  384. ////////////////////// Internal methods //////////////////////
  385. void CConn::resizeFramebuffer()
  386. {
  387. if (!desktop)
  388. return;
  389. if (continuousUpdates)
  390. writer()->writeEnableContinuousUpdates(true, 0, 0, cp.width, cp.height);
  391. desktop->resizeFramebuffer(cp.width, cp.height);
  392. }
  393. // autoSelectFormatAndEncoding() chooses the format and encoding appropriate
  394. // to the connection speed:
  395. //
  396. // First we wait for at least one second of bandwidth measurement.
  397. //
  398. // Above 16Mbps (i.e. LAN), we choose the second highest JPEG quality,
  399. // which should be perceptually lossless.
  400. //
  401. // If the bandwidth is below that, we choose a more lossy JPEG quality.
  402. //
  403. // If the bandwidth drops below 256 Kbps, we switch to palette mode.
  404. //
  405. // Note: The system here is fairly arbitrary and should be replaced
  406. // with something more intelligent at the server end.
  407. //
  408. void CConn::autoSelectFormatAndEncoding()
  409. {
  410. int kbitsPerSecond = sock->inStream().kbitsPerSecond();
  411. unsigned int timeWaited = sock->inStream().timeWaited();
  412. bool newFullColour = fullColour;
  413. int newQualityLevel = qualityLevel;
  414. // Always use Tight
  415. if (currentEncoding != encodingTight) {
  416. currentEncoding = encodingTight;
  417. encodingChange = true;
  418. }
  419. // Check that we have a decent bandwidth measurement
  420. if ((kbitsPerSecond == 0) || (timeWaited < 10000))
  421. return;
  422. // Select appropriate quality level
  423. if (!noJpeg) {
  424. if (kbitsPerSecond > 16000)
  425. newQualityLevel = 8;
  426. else
  427. newQualityLevel = 6;
  428. if (newQualityLevel != qualityLevel) {
  429. vlog.info(_("Throughput %d kbit/s - changing to quality %d"),
  430. kbitsPerSecond, newQualityLevel);
  431. cp.qualityLevel = newQualityLevel;
  432. qualityLevel.setParam(newQualityLevel);
  433. encodingChange = true;
  434. }
  435. }
  436. if (cp.beforeVersion(3, 8)) {
  437. // Xvnc from TightVNC 1.2.9 sends out FramebufferUpdates with
  438. // cursors "asynchronously". If this happens in the middle of a
  439. // pixel format change, the server will encode the cursor with
  440. // the old format, but the client will try to decode it
  441. // according to the new format. This will lead to a
  442. // crash. Therefore, we do not allow automatic format change for
  443. // old servers.
  444. return;
  445. }
  446. // Select best color level
  447. newFullColour = (kbitsPerSecond > 256);
  448. if (newFullColour != fullColour) {
  449. vlog.info(_("Throughput %d kbit/s - full color is now %s"),
  450. kbitsPerSecond,
  451. newFullColour ? _("enabled") : _("disabled"));
  452. fullColour.setParam(newFullColour);
  453. formatChange = true;
  454. }
  455. }
  456. // checkEncodings() sends a setEncodings message if one is needed.
  457. void CConn::checkEncodings()
  458. {
  459. if (encodingChange && writer()) {
  460. vlog.info(_("Using %s encoding"),encodingName(currentEncoding));
  461. writer()->writeSetEncodings(currentEncoding, true);
  462. encodingChange = false;
  463. }
  464. }
  465. // requestNewUpdate() requests an update from the server, having set the
  466. // format and encoding appropriately.
  467. void CConn::requestNewUpdate()
  468. {
  469. if (formatChange) {
  470. PixelFormat pf;
  471. /* Catch incorrect requestNewUpdate calls */
  472. assert(!pendingUpdate || supportsSyncFence);
  473. if (fullColour) {
  474. pf = fullColourPF;
  475. } else {
  476. if (lowColourLevel == 0)
  477. pf = verylowColourPF;
  478. else if (lowColourLevel == 1)
  479. pf = lowColourPF;
  480. else
  481. pf = mediumColourPF;
  482. }
  483. if (supportsSyncFence) {
  484. // We let the fence carry the pixel format and switch once we
  485. // get the response back. That way we will be synchronised with
  486. // when the server switches.
  487. rdr::MemOutStream memStream;
  488. pf.write(&memStream);
  489. writer()->writeFence(fenceFlagRequest | fenceFlagSyncNext,
  490. memStream.length(), (const char*)memStream.data());
  491. } else {
  492. // New requests are sent out at the start of processing the last
  493. // one, so we cannot switch our internal format right now (doing so
  494. // would mean misdecoding the current update).
  495. pendingPFChange = true;
  496. pendingPF = pf;
  497. }
  498. char str[256];
  499. pf.print(str, 256);
  500. vlog.info(_("Using pixel format %s"),str);
  501. writer()->writeSetPixelFormat(pf);
  502. formatChange = false;
  503. }
  504. checkEncodings();
  505. if (forceNonincremental || !continuousUpdates) {
  506. pendingUpdate = true;
  507. writer()->writeFramebufferUpdateRequest(Rect(0, 0, cp.width, cp.height),
  508. !forceNonincremental);
  509. }
  510. forceNonincremental = false;
  511. }
  512. void CConn::handleOptions(void *data)
  513. {
  514. CConn *self = (CConn*)data;
  515. // Checking all the details of the current set of encodings is just
  516. // a pain. Assume something has changed, as resending the encoding
  517. // list is cheap. Avoid overriding what the auto logic has selected
  518. // though.
  519. if (!autoSelect) {
  520. int encNum = encodingNum(preferredEncoding);
  521. if (encNum != -1)
  522. self->currentEncoding = encNum;
  523. }
  524. self->cp.supportsLocalCursor = true;
  525. if (customCompressLevel)
  526. self->cp.compressLevel = compressLevel;
  527. else
  528. self->cp.compressLevel = -1;
  529. if (!noJpeg && !autoSelect)
  530. self->cp.qualityLevel = qualityLevel;
  531. else
  532. self->cp.qualityLevel = -1;
  533. self->encodingChange = true;
  534. // Format changes refreshes the entire screen though and are therefore
  535. // very costly. It's probably worth the effort to see if it is necessary
  536. // here.
  537. PixelFormat pf;
  538. if (fullColour) {
  539. pf = self->fullColourPF;
  540. } else {
  541. if (lowColourLevel == 0)
  542. pf = verylowColourPF;
  543. else if (lowColourLevel == 1)
  544. pf = lowColourPF;
  545. else
  546. pf = mediumColourPF;
  547. }
  548. if (!pf.equal(self->cp.pf())) {
  549. self->formatChange = true;
  550. // Without fences, we cannot safely trigger an update request directly
  551. // but must wait for the next update to arrive.
  552. if (self->supportsSyncFence)
  553. self->requestNewUpdate();
  554. }
  555. }