vncthread.cpp

Go to the documentation of this file.

/*
 # Copyright (c) 2009, 2010 - OpenSLX Project, Computer Center University of
 # Freiburg
 #
 # This program is free software distributed under the GPL version 2.
 # See http://openslx.org/COPYING
 #
 # If you have any feedback please consult http://openslx.org/feedback and
 # send your suggestions, praise, or complaints to [email protected]
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # -----------------------------------------------------------------------------
 # vncClientThread.cpp
 #  - Connection to remove vnc server
 #  - Emits Qt signal on framebuffer updates
 # -----------------------------------------------------------------------------
 */

#include "vncthread.h"
#include "../../shared/util.h"

#include <QPainter>
#include <utility>
#include <netinet/tcp.h>

VncThread::VncThread(QString host, int port, QString passwd, int quality)
      : QThread()
      , _host(std::move(host))
      , _port(port)
      , _passwd(std::move(passwd))
      , _quality(quality)
      , _run(true)
      , _started(false)
{
   moveToThread(this);
}

VncThread::~VncThread()
{
   qDebug("VNC worker destructor called.");
   Q_ASSERT(_run == false);
   if (_client != nullptr) {
      if (_client->sock != -1)
         ::close(_client->sock);
      _client->sock = -1;
      rfbClientCleanup(_client);
   }
}

// Public

void VncThread::run()
{
   qDebug("[%s] VNC client started.", metaObject()->className());
   qDebug("[%s] Host: '%s' Port: %i Passwd: '%s' Quality: %i", metaObject()->className(), qPrintable(_host), _port,
          qPrintable(_passwd), _quality);

   // setup network
   for (int retry = 0; retry < 5 && _run; ++retry) {
      msleep(1 + slxrand() % 60);
      if (!_run)
         break;
      _client = rfbGetClient(8, 3, 4);
      _client->MallocFrameBuffer = &frameBufferHandler;
      _client->canHandleNewFBSize = true;
      free(_client->serverHost); // in rfbGetClient, serverHost is assigned strdup(""), so free that first.
      _client->serverHost = strdup(_host.toUtf8().constData());
      _client->desktopName = nullptr;
      _client->serverPort = _port;
      _client->GetPassword = &passwdHandler;
      _client->GotFrameBufferUpdate = &updateImage;
      _client->frameBuffer = nullptr;

      // save this instance in vnc-struct for callbacks
      rfbClientSetClientData(_client, nullptr, this);

      // start client
      if (rfbInitClient(_client, nullptr, nullptr)) {
         break; // Success!
      }
      // Connection failed
      _client = nullptr; // InitClient frees the client on failure, so make sure we don't keep an invalid pointer around
      if (!_run)
         break;
      // error, let's try again
      msleep(10 + slxrand() % 50);
   }
   if (_client != nullptr) {
      qDebug("[%s] Connection successful!", metaObject()->className());
      int one = 1;
      setsockopt(_client->sock, SOL_TCP, TCP_NODELAY, &one, sizeof(one));
      one = 1;
      setsockopt(_client->sock, SOL_TCP, TCP_QUICKACK, &one, sizeof(one));

      // Main VNC event loop
      if (_run) {
         _connected = true;
      }
      while (_run) {
         const int i = WaitForMessage(_client, 100 * 1000); // wait 100ms for message. returns -1 on error/disconnect, 0 if nothing happened, 1 if new data arrived
         if (i < 0)
            break;
         if (i > 0 && !HandleRFBServerMessage(_client))
            break;
      }
   }

   _connected = false;
   emit projectionStopped();
   while (_run)
      msleep(100);
   qDebug("[%s] VNC client stopped.", metaObject()->className());
}

QString VncThread::getDesktopName() const
{
   if (_client == nullptr || _client->desktopName == nullptr)
      return {};
   return QString(_client->desktopName);
}

void VncThread::processImageUpdate(int x, int y, int w, int h)
{
   emit imageUpdated(x, y, w, h);
}

void VncThread::emitStarted()
{
   emit projectionStarted();
}

// *** callback stuff ***

char* VncThread::passwdHandler(rfbClient *client)
{
   auto* t = reinterpret_cast<VncThread*>(rfbClientGetClientData(client, nullptr));
   return strdup(t->_passwd.toUtf8());
}

rfbBool VncThread::frameBufferHandler(rfbClient *client)
{
   auto *t = reinterpret_cast<VncThread*>(rfbClientGetClientData(client, nullptr));
   const int width = client->width, height = client->height, depth = 32;
   const int size = width * height * (depth / 8);
   qDebug("[%s] Remote desktop: %ix%ix%i", t->metaObject()->className(), width, height, depth);
   if (width < 0 || height < 0 || size < 0) {
      qWarning() << "IGNORING INVALID FRAMEBUFFER SIZE";
      client->frameBuffer = nullptr;
      return false;
   }

   t->_img = QSharedPointer<QImage>(new QImage(width, height, QImage::Format_RGB32));
   if (size > t->_img->sizeInBytes()) {
      qDebug() << "Fatal: Created image too small:" << t->_img->sizeInBytes() << "<" << size;
      ::exit(1);
   }
   client->frameBuffer = t->_img->bits();
   memset(client->frameBuffer, '\0', size_t(size));
   client->format.trueColour = 1;
   client->format.bitsPerPixel = depth;
   client->format.redShift = 16;
   client->format.greenShift = 8;
   client->format.blueShift = 0;
   client->format.redMax = 0xff;
   client->format.greenMax = 0xff;
   client->format.blueMax = 0xff;

   const int quality = t->_quality;
   switch (quality) {
   case VncThread::HIGH:
      client->appData.useBGR233 = 0;
      client->appData.encodingsString = "copyrect zlib hextile raw";
      client->appData.compressLevel = 4;
      client->appData.qualityLevel = 9;
      client->appData.scaleSetting = 0;
      break;
   case VncThread::MEDIUM:
      client->appData.useBGR233 = 0;
      client->appData.encodingsString = "copyrect tight zrle ultra zlib hextile corre rre raw";
      client->appData.compressLevel = 7;
      client->appData.qualityLevel = 8;
      client->appData.scaleSetting = 0;
      break;
   case VncThread::LOW:
   default:
      client->appData.useBGR233 = 1;
      client->appData.encodingsString = "copyrect tight zrle ultra zlib hextile corre rre raw";
      client->appData.compressLevel = 9;
      client->appData.qualityLevel = 1;
      client->appData.scaleSetting = 0;
      break;
   }
   SetFormatAndEncodings(client);

   SendFramebufferUpdateRequest(client, 0, 0, width, height, false);

   if (!t->_started) {
      t->_started = true;
      t->emitStarted();
   }

   return true;
}

void VncThread::updateImage(rfbClient* client, int x, int y, int w, int h)
{
   auto* t = (VncThread*)rfbClientGetClientData(client, 0);
   t->processImageUpdate(x, y, w, h);
}