krdc/vnc/vncclientthread.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2007-2008 Urs Wolfer <uwolfer @ kde.org>
   4 **
   5 ** This file is part of KDE.
   6 **
   7 ** This program is free software; you can redistribute it and/or modify
   8 ** it under the terms of the GNU General Public License as published by
   9 ** the Free Software Foundation; either version 2 of the License, or
  10 ** (at your option) any later version.
  11 **
  12 ** This program is distributed in the hope that it will be useful,
  13 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 ** GNU General Public License for more details.
  16 **
  17 ** You should have received a copy of the GNU General Public License
  18 ** along with this program; see the file COPYING. If not, write to
  19 ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 ** Boston, MA 02110-1301, USA.
  21 **
  22 ****************************************************************************/
  23
  24 #include "vncclientthread.h"
  25
  26 #include <QMutexLocker>
  27 #include <QTimer>
  28
  29 static QString outputErrorMessageString;
  30
  31 static uint8_t *buf = 0;
  32
  33 rfbBool VncClientThread::newclient(rfbClient *cl)
  34 {
  35     int width = cl->width, height = cl->height, depth = cl->format.bitsPerPixel;
  36     int size = width * height * (depth / 8);
  37     if (cl->frameBuffer)
  38         delete [] buf; // do not leak if we get a new framebuffer size
  39     buf = new uint8_t[size];
  40     memset(buf, '\0', size);
  41     cl->frameBuffer = buf;
  42     cl->format.bitsPerPixel = 32;
  43     cl->format.redShift = 16;
  44     cl->format.greenShift = 8;
  45     cl->format.blueShift = 0;
  46     cl->format.redMax = 0xff;
  47     cl->format.greenMax = 0xff;
  48     cl->format.blueMax = 0xff;
  49
  50     VncClientThread *t = (VncClientThread*)rfbClientGetClientData(cl, 0);
  51
  52     switch (t->quality()) {
  53     case RemoteView::High:
  54         cl->appData.useBGR233 = 0;
  55         cl->appData.encodingsString = "copyrect hextile raw";
  56         cl->appData.compressLevel = 0;
  57         cl->appData.qualityLevel = 9;
  58         break;
  59     case RemoteView::Medium:
  60         cl->appData.useBGR233 = 0;
  61         cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";
  62         cl->appData.compressLevel = 5;
  63         cl->appData.qualityLevel = 7;
  64         break;
  65     case RemoteView::Low:
  66     case RemoteView::Unknown:
  67     default:
  68         cl->appData.useBGR233 = 1;
  69         cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";
  70         cl->appData.compressLevel = 9;
  71         cl->appData.qualityLevel = 1;
  72     }
  73
  74     SetFormatAndEncodings(cl);
  75
  76     return true;
  77 }
  78
  79 void VncClientThread::updatefb(rfbClient* cl, int x, int y, int w, int h)
  80 {
  81 //     kDebug(5011) << "updated client: x: " << x << ", y: " << y << ", w: " << w << ", h: " << h;
  82
  83     int width = cl->width, height = cl->height;
  84
  85     QImage img(cl->frameBuffer, width, height, QImage::Format_RGB32);
  86
  87     if (img.isNull())
  88         kDebug(5011) << "image not loaded";
  89
  90
  91     VncClientThread *t = (VncClientThread*)rfbClientGetClientData(cl, 0);
  92
  93     if (!t)
  94         return;
  95
  96     t->setImage(img);
  97
  98     t->emitUpdated(x, y, w, h);
  99 }
 100
 101 void VncClientThread::cuttext(rfbClient* cl, const char *text, int textlen)
 102 {
 103     QString cutText = QString::fromUtf8(text, textlen);
 104     kDebug(5011) << cutText;
 105
 106     if (!cutText.isEmpty()) {
 107         VncClientThread *t = (VncClientThread*)rfbClientGetClientData(cl, 0);
 108
 109         if (!t)
 110             return;
 111
 112         t->emitGotCut(cutText);
 113     }
 114 }
 115
 116 char *VncClientThread::passwdHandler(rfbClient *cl)
 117 {
 118     kDebug(5011) << "password request" << kBacktrace();
 119
 120     VncClientThread *t = (VncClientThread*)rfbClientGetClientData(cl, 0);
 121
 122     if (!t)
 123         return 0;
 124
 125     t->passwordRequest();
 126     t->m_passwordError = true;
 127
 128     return strdup(t->password().toLocal8Bit());
 129 }
 130
 131 void VncClientThread::outputHandler(const char *format, ...)
 132 {
 133     va_list args;
 134     va_start(args, format);
 135
 136     QString message;
 137     message.vsprintf(format, args);
 138
 139     va_end(args);
 140
 141     message = message.trimmed();
 142
 143     kDebug(5011) << message;
 144
 145     if ((message.contains("Couldn't convert ")) ||
 146             (message.contains("Unable to connect to VNC server")))
 147         outputErrorMessageString = i18n("Server not found.");
 148
 149     if ((message.contains("VNC connection failed: Authentication failed, too many tries")) ||
 150             (message.contains("VNC connection failed: Too many authentication failures")))
 151         outputErrorMessageString = i18n("VNC authentication failed because of too many authentication tries.");
 152
 153     if (message.contains("VNC connection failed: Authentication failed"))
 154         outputErrorMessageString = i18n("VNC authentication failed.");
 155
 156     if (message.contains("VNC server closed connection"))
 157         outputErrorMessageString = i18n("VNC server closed connection.");
 158
 159     // internal messages, not displayed to user
 160     if (message.contains("VNC server supports protocol version 3.889")) // see http://bugs.kde.org/162640
 161         outputErrorMessageString = "INTERNAL:APPLE_VNC_COMPATIBILTY";
 162 }
 163
 164 VncClientThread::VncClientThread(QObject *parent)
 165         : QThread(parent)
 166 {
 167     QMutexLocker locker(&mutex);
 168     m_stopped = false;
 169
 170     QTimer *outputErrorMessagesCheckTimer = new QTimer(this);
 171     outputErrorMessagesCheckTimer->setInterval(500);
 172     connect(outputErrorMessagesCheckTimer, SIGNAL(timeout()), this, SLOT(checkOutputErrorMessage()));
 173     outputErrorMessagesCheckTimer->start();
 174 }
 175
 176 VncClientThread::~VncClientThread()
 177 {
 178     stop();
 179     wait(500);
 180 }
 181
 182 void VncClientThread::checkOutputErrorMessage()
 183 {
 184     if (!outputErrorMessageString.isEmpty()) {
 185         kDebug(5011) << outputErrorMessageString;
 186         QString errorMessage = outputErrorMessageString;
 187         outputErrorMessageString.clear();
 188         // show authentication failure error only after the 3rd unsuccessful try
 189         if ((errorMessage != i18n("VNC authentication failed.")) || m_passwordError)
 190             outputErrorMessage(errorMessage);
 191     }
 192 }
 193
 194 void VncClientThread::setHost(const QString &host)
 195 {
 196     QMutexLocker locker(&mutex);
 197     m_host = host;
 198 }
 199
 200 void VncClientThread::setPort(int port)
 201 {
 202     QMutexLocker locker(&mutex);
 203     m_port = port;
 204 }
 205
 206 void VncClientThread::setQuality(RemoteView::Quality quality)
 207 {
 208     m_quality = quality;
 209 }
 210
 211 RemoteView::Quality VncClientThread::quality() const
 212 {
 213     return m_quality;
 214 }
 215
 216 void VncClientThread::setImage(const QImage &img)
 217 {
 218     QMutexLocker locker(&mutex);
 219     m_image = img;
 220 }
 221
 222 const QImage VncClientThread::image(int x, int y, int w, int h)
 223 {
 224     QMutexLocker locker(&mutex);
 225
 226     if (w == 0) // full image requested
 227         return m_image;
 228     else
 229         return m_image.copy(x, y, w, h);
 230 }
 231
 232 void VncClientThread::emitUpdated(int x, int y, int w, int h)
 233 {
 234     emit imageUpdated(x, y, w, h);
 235 }
 236
 237 void VncClientThread::emitGotCut(const QString &text)
 238 {
 239     emit gotCut(text);
 240 }
 241
 242 void VncClientThread::stop()
 243 {
 244     QMutexLocker locker(&mutex);
 245     m_stopped = true;
 246 }
 247
 248 void VncClientThread::run()
 249 {
 250     QMutexLocker locker(&mutex);
 251
 252     while (!m_stopped) { // try to connect as long as the server allows
 253         m_passwordError = false;
 254
 255         rfbClientLog = outputHandler;
 256         rfbClientErr = outputHandler;
 257         cl = rfbGetClient(8, 3, 4);
 258         cl->MallocFrameBuffer = newclient;
 259         cl->canHandleNewFBSize = true;
 260         cl->GetPassword = passwdHandler;
 261         cl->GotFrameBufferUpdate = updatefb;
 262         cl->GotXCutText = cuttext;
 263         rfbClientSetClientData(cl, 0, this);
 264
 265         cl->serverHost = strdup(m_host.toUtf8().constData());
 266
 267         if (m_port < 0 || !m_port) // port is invalid or empty...
 268             m_port = 5900; // fallback: try an often used VNC port
 269
 270         if (m_port >= 0 && m_port < 100) // the user most likely used the short form (e.g. :1)
 271             m_port += 5900;
 272         cl->serverPort = m_port;
 273
 274         kDebug(5011) << "--------------------- trying init ---------------------";
 275
 276         if (rfbInitClient(cl, 0, 0))
 277             break;
 278
 279         if (m_passwordError)
 280             continue;
 281
 282         return;
 283     }
 284
 285     locker.unlock();
 286
 287     // Main VNC event loop
 288     while (!m_stopped) {
 289         int i = WaitForMessage(cl, 500);
 290         if (i < 0)
 291             break;
 292         if (i)
 293             if (!HandleRFBServerMessage(cl))
 294                 break;
 295
 296         locker.relock();
 297
 298         while (!m_eventQueue.isEmpty()) {
 299             ClientEvent* clientEvent = m_eventQueue.dequeue();
 300             clientEvent->fire(cl);
 301             delete clientEvent;
 302         }
 303
 304         locker.unlock();
 305     }
 306
 307     // Cleanup allocated resources
 308     locker.relock();
 309     delete [] cl->frameBuffer;
 310     cl->frameBuffer = 0;
 311     rfbClientCleanup(cl);
 312     buf = 0;
 313     m_stopped = true;
 314 }
 315
 316 ClientEvent::~ClientEvent()
 317 {
 318 }
 319
 320 void PointerClientEvent::fire(rfbClient* cl)
 321 {
 322     SendPointerEvent(cl, m_x, m_y, m_buttonMask);
 323 }
 324
 325 void KeyClientEvent::fire(rfbClient* cl)
 326 {
 327     SendKeyEvent(cl, m_key, m_pressed);
 328 }
 329
 330 void ClientCutEvent::fire(rfbClient* cl)
 331 {
 332     SendClientCutText(cl, text, qstrlen(text));
 333 }
 334
 335 void VncClientThread::mouseEvent(int x, int y, int buttonMask)
 336 {
 337     QMutexLocker lock(&mutex);
 338     if (m_stopped)
 339         return;
 340
 341     m_eventQueue.enqueue(new PointerClientEvent(x, y, buttonMask));
 342 }
 343
 344 void VncClientThread::keyEvent(int key, bool pressed)
 345 {
 346     QMutexLocker lock(&mutex);
 347     if (m_stopped)
 348         return;
 349
 350     m_eventQueue.enqueue(new KeyClientEvent(key, pressed));
 351 }
 352
 353 void VncClientThread::clientCut(const QString &text)
 354 {
 355     QMutexLocker lock(&mutex);
 356     if (m_stopped)
 357         return;
 358
 359     m_eventQueue.enqueue(new ClientCutEvent(strdup(text.toUtf8())));
 360 }
 361
 362 #include "moc_vncclientthread.cpp"