玉兔远程控制 0.1.0-bate11
载入中...
搜索中...
未找到
BackendVnc.cpp
1// Author: Kang Lin <kl222@126.com>
2
3#include "BackendVnc.h"
4#include "OperateDesktop.h"
5
6#ifndef WIN32
7#include <string.h>
8#include "network/UnixSocket.h"
9#endif
10
11#include <rfb/CMsgWriter.h>
12#include <rfb/Hostname.h>
13#include "rfb/LogWriter.h"
14#include <rfb/util.h>
15#include <rfb/clipboardTypes.h>
16#include <rfb/LogWriter.h>
17#include <rfb/Logger_stdio.h>
18#include <rfb/fenceTypes.h>
19
20// the X11 headers on some systems
21#ifndef XK_VoidSymbol
22#define XK_LATIN1
23#define XK_MISCELLANY
24#define XK_XKB_KEYS
25#include <rfb/keysymdef.h>
26#endif
27
28
29#include "FramePixelBuffer.h"
30
31#include <QDir>
32#include <QMimeData>
33#include <QClipboard>
34#include <QApplication>
35#include <QLoggingCategory>
36#include <QThread>
37#include <QKeyEvent>
38#include <QMouseEvent>
39#include <QNetworkProxy>
40#include <QMutex>
41#include <QInputDialog>
42
43#include "rfb/Security.h"
44#include "rfb/Exception.h"
45#ifdef HAVE_GNUTLS
46#include "rfb/CSecurityTLS.h"
47#endif
48
49#ifdef HAVE_ICE
50 #include "Ice.h"
51 #include "ChannelIce.h"
52#endif
53
54#ifdef HAVE_LIBSSH
55 #include "ChannelSSHTunnel.h"
56#endif
57
58static Q_LOGGING_CATEGORY(log, "VNC.Backend")
59static Q_LOGGING_CATEGORY(logVNC, "VNC.Log")
60static Q_LOGGING_CATEGORY(logKey, "VNC.Backend.Key")
61static Q_LOGGING_CATEGORY(logInputMethod, "VNC.Backend.InputMethod")
62static Q_LOGGING_CATEGORY(logMouse, "VNC.Backend.Mouse")
63
64class VncLogger: public rfb::Logger
65{
66public:
67 VncLogger(const char *name) : rfb::Logger(name)
68 {}
69 void write(int level, const char *logname, const char *text) override
70 {
71 if (level >= rfb::LogWriter::LEVEL_DEBUG) {
72 qDebug(logVNC) << logname << text;
73 } else if (level >= rfb::LogWriter::LEVEL_INFO) {
74 qInfo(logVNC) << logname << text;
75 } else if (level >= rfb::LogWriter::LEVEL_STATUS) {
76 qWarning(logVNC) << logname << text;
77 } else {
78 qCritical(logVNC) << logname << text;
79 }
80 }
81};
82
83static VncLogger g_logger("Rabbit");
84
85// 8 colours (1 bit per component)
86static const rfb::PixelFormat verylowColourPF(8, 3,false, true, 1, 1, 1, 2, 1, 0);
87// 64 colours (2 bits per component)
88static const rfb::PixelFormat lowColourPF(8, 6, false, true, 3, 3, 3, 4, 2, 0);
89// 256 colours (2-3 bits per component)
90static const rfb::PixelFormat mediumColourPF(8, 8, false, true, 7, 7, 3, 5, 2, 0);
91
92// RGB (4 bits per component)
93static const rfb::PixelFormat fullColourPF(32, 24, false, true, 255, 255, 255, 16, 8, 0);
94
95// Time new bandwidth estimates are weighted against (in ms)
96static const unsigned bpsEstimateWindow = 1000;
97
98CBackendVnc::CBackendVnc(COperateDesktop *pOperate)
99 : CBackendDesktop(pOperate)
100 , m_pOperate(pOperate)
101 , m_pPara(nullptr)
102 , m_SecurityLevel(CSecurityLevel::Level::Risk)
103{
104 static bool initlog = false;
105 if(!initlog)
106 {
107 g_logger.registerLogger();
108 rfb::LogWriter::setLogParams("*:Rabbit:100");
109 /*rfb::initStdIOLoggers();
110 rfb::LogWriter::setLogParams("*:stderr:100");
111 QString szFile = RabbitCommon::CDir::Instance()->GetDirLog()
112 + QDir::separator()
113 + "TigerVnc.log";
114 rfb::initFileLogger(szFile.toStdString().c_str());
115 rfb::LogWriter::setLogParams("*:file:100");
116 */
117 initlog = true;
118 }
119 m_pPara = dynamic_cast<CParameterVnc*>(pOperate->GetParameter());
120 Q_ASSERT(m_pPara);
121
122 if(!m_pPara->GetLocalCursor())
123 {
124 emit sigUpdateCursor(QCursor(Qt::BlankCursor));
125 }
126}
127
128CBackendVnc::~CBackendVnc()
129{
130 qDebug(log) << "CConnectVnc::~CConnectVnc()";
131}
132
133int CBackendVnc::SetPara()
134{
135 QDir d(os::getvncconfigdir());
136 if(!d.exists())
137 d.mkpath(os::getvncconfigdir());
138 QDir dstat(os::getvncstatedir());
139 if(!dstat.exists())
140 dstat.mkpath(os::getvncstatedir());
141 QDir dvnc(os::getvncdatadir());
142 if(!dvnc.exists())
143 dvnc.mkpath(os::getvncdatadir());
144
145 setServerName(m_pPara->m_Net.GetHost().toStdString().c_str());
146 setShared(m_pPara->GetShared());
147 supportsLocalCursor = m_pPara->GetLocalCursor();
148 supportsCursorPosition = m_pPara->GetCursorPosition();
149 supportsDesktopResize = m_pPara->GetSupportsDesktopResize();
150 supportsLEDState = m_pPara->GetLedState();
151
152 std::list<uint32_t> sec;
153 switch(m_pPara->m_Net.m_User.GetUsedType()) {
154 case CParameterUser::TYPE::None:
155 sec.push_back(rfb::secTypeNone);
156 break;
157 case CParameterUser::TYPE::OnlyPassword:
158 sec.push_back(rfb::secTypeVncAuth);
159 break;
160 case CParameterUser::TYPE::UserPassword:
161 sec.push_back(rfb::secTypePlain);
162 break;
163 case CParameterUser::TYPE::OnlyPasswordX509None:
164 sec.push_back(rfb::secTypeTLSVnc);
165 break;
166 case CParameterUser::TYPE::OnlyPasswordX509:
167 sec.push_back(rfb::secTypeX509Vnc);
168 break;
169 case CParameterUser::TYPE::UserPasswordX509None:
170 sec.push_back(rfb::secTypeTLSPlain);
171 break;
172 case CParameterUser::TYPE::UserPasswordX509:
173 sec.push_back(rfb::secTypeX509Plain);
174 break;
175 //TODO: add authentication
176 }
177 //*
178 qDebug(log) << "secTypes:" << security.GetEnabledSecTypes() << security.ToString()
179 << "new:" << sec; // << "Type:" << m_pPara->m_Net.m_User.GetType();//*/
180 security.SetSecTypes(sec);
181
182 // Set Preferred Encoding
183 setPreferredEncoding(m_pPara->GetPreferredEncoding());
184 setCompressLevel(m_pPara->GetCompressLevel());
185 setQualityLevel(m_pPara->GetQualityLevel());
186
187 // Set server pixmap format
188 updatePixelFormat();
189 return 0;
190}
191
192/*
193 * \return
194 * \li OnInitReturnValue::Fail: error
195 * \li OnInitReturnValue::UseOnProcess: Use OnProcess (non-Qt event loop)
196 * \li OnInitReturnValue::NotUseOnProcess: Don't use OnProcess (qt event loop)
197 */
198CBackendVnc::OnInitReturnValue CBackendVnc::OnInit()
199{
200 qDebug(log) << "CConnectVnc::OnInit()";
201 int nRet = 0;
202
203 if(m_pPara->GetIce())
204 nRet = IceInit();
205 else {
206#ifdef HAVE_LIBSSH
207 if(m_pPara->m_Proxy.GetUsedType() == CParameterProxy::TYPE::SSHTunnel) {
208 nRet = SSHInit();
209 if(nRet) return OnInitReturnValue::Fail; // error
210 return OnInitReturnValue::UseOnProcess;
211 }
212#endif
213 nRet = SocketInit();
214 }
215 if(nRet) return OnInitReturnValue::Fail; // error
216 // Don't use OnProcess (qt event loop)
217 return OnInitReturnValue::NotUseOnProcess;
218}
219
220int CBackendVnc::IceInit()
221{
222#ifdef HAVE_ICE
223 CIceSignal* pSignal = CICE::Instance()->GetSignal().data();
224 if(!pSignal || !pSignal->IsConnected())
225 {
226 qCritical(log) << "The g_pSignal is null. or signal don't connect server";
227 return -1;
228 }
229
230 qInfo(log, "Connected to signal server:%s:%d; user:%s",
231 CICE::Instance()->GetParameter()->getSignalServer().toStdString().c_str(),
232 CICE::Instance()->GetParameter()->getSignalPort(),
233 CICE::Instance()->GetParameter()->getSignalUser().toStdString().c_str());
234 auto channel = QSharedPointer<CChannelIce>(new CChannelIce(pSignal));
235 if(!channel)
236 {
237 qCritical(log) << "new CDataChannelIce fail";
238 return -2;
239 }
240 m_DataChannel = channel;
241 SetChannelConnect(channel);
242
243 rtc::Configuration config;
244 rtc::IceServer stun(CICE::Instance()->GetParameter()->getStunServer().toStdString().c_str(),
245 CICE::Instance()->GetParameter()->getStunPort());
246 rtc::IceServer turn(CICE::Instance()->GetParameter()->getTurnServer().toStdString().c_str(),
247 CICE::Instance()->GetParameter()->getTurnPort(),
248 CICE::Instance()->GetParameter()->getTurnUser().toStdString().c_str(),
249 CICE::Instance()->GetParameter()->getTurnPassword().toStdString().c_str());
250 config.iceServers.push_back(stun);
251 config.iceServers.push_back(turn);
252 channel->SetConfigure(config);
253
254 bool bRet = channel->open(CICE::Instance()->GetParameter()->getSignalUser(),
255 m_pPara->GetPeerUser(), true);
256 if(!bRet)
257 {
258 emit sigError(-1, "Open channel fail");
259 }
260
261#endif
262 return 0;
263}
264
265int CBackendVnc::SocketInit()
266{
267 int nRet = 0;
268 try{
269 QTcpSocket* pSock = new QTcpSocket(this);
270 if(!pSock)
271 return -1;
272 m_DataChannel = QSharedPointer<CChannel>(new CChannel(pSock));
273 if(!m_DataChannel) {
274 qCritical(log) << "New CChannel fail";
275 return -1;
276 }
277
278 SetChannelConnect(m_DataChannel);
279
280 if(!m_DataChannel->open(QIODevice::ReadWrite))
281 {
282 qCritical(log) << "Open channel fail";
283 return -1;
284 }
285
286 QNetworkProxy::ProxyType type = QNetworkProxy::NoProxy;
287 // Set sock
288 switch(m_pPara->m_Proxy.GetUsedType())
289 {
290 case CParameterProxy::TYPE::SockesV5:
291 type = QNetworkProxy::Socks5Proxy;
292 break;
293 case CParameterProxy::TYPE::System:
294 type = QNetworkProxy::DefaultProxy;
295 break;
296 case CParameterProxy::TYPE::Http:
297 type = QNetworkProxy::HttpProxy;
298 break;
299 case CParameterProxy::TYPE::None:
300 default:
301 break;
302 }
303
304 switch(type) {
305 case QNetworkProxy::DefaultProxy:
306 {
307 pSock->setProxy(QNetworkProxy::applicationProxy());
308 break;
309 }
310 case QNetworkProxy::HttpProxy:
311 case QNetworkProxy::Socks5Proxy:
312 {
313 QNetworkProxy proxy;
314 auto net = &m_pPara->m_Proxy.m_SockesV5;
315 if(QNetworkProxy::HttpProxy == type) {
316 net = &m_pPara->m_Proxy.m_Http;
317 }
318 if(net->GetHost().isEmpty())
319 {
320 QString szErr;
321 szErr = tr("The proxy server is empty, please input it");
322 qCritical(log) << szErr;
323 emit sigShowMessageBox(tr("Error"), szErr, QMessageBox::Critical);
324 return -1;
325 }
326 proxy.setHostName(net->GetHost());
327 proxy.setPort(net->GetPort());
328 auto &user = net->m_User;
329 if(((user.GetUsedType() == CParameterUser::TYPE::UserPassword)
330 && (user.GetPassword().isEmpty() || user.GetUser().isEmpty()))
331 || ((user.GetUsedType() == CParameterUser::TYPE::PublicKey)
332 && user.GetPassphrase().isEmpty())) {
333 int nRet = QDialog::Rejected;
334 emit sigBlockShowWidget("CDlgUserPassword", nRet, net);
335 if(QDialog::Accepted != nRet)
336 {
337 return -1;
338 }
339 }
340 proxy.setUser(user.GetUser());
341 proxy.setPassword(user.GetPassword());
342 proxy.setType(type);
343 pSock->setProxy(proxy);
344 break;
345 }
346 default:
347 break;
348 }
349
350 if(m_pPara->m_Net.GetHost().isEmpty())
351 {
352 QString szErr;
353 szErr = tr("The server is empty, please input it");
354 qCritical(log) << szErr;
355 emit sigShowMessageBox(tr("Error"), szErr, QMessageBox::Critical);
356 return -1;
357 }
358 pSock->connectToHost(m_pPara->m_Net.GetHost(), m_pPara->m_Net.GetPort());
359
360 QString serverHost;
361 serverHost = pSock->peerName();
362 qDebug(log) << "Server Host:" << serverHost;
363 setServerName(serverHost.toStdString().c_str());
364
365 return nRet;
366 } catch (rdr::Exception& e) {
367 qCritical(log) << "SocketInit exception:" << e.str();
368 emit sigError(-1, e.str());
369 nRet = -1;
370 }
371 return nRet;
372}
373
374int CBackendVnc::SSHInit()
375{
376#ifdef HAVE_LIBSSH
377 auto channel = QSharedPointer<CChannelSSHTunnel>(
378 new CChannelSSHTunnel(&m_pPara->m_Proxy.m_SSH, &m_pPara->m_Net, this));
379 if(!channel) {
380 qCritical(log) << "New CChannelSSHTunnel fail";
381 return -1;
382 }
383 m_DataChannel = channel;
384 SetChannelConnect(m_DataChannel);
385 if(!channel->open(QIODevice::ReadWrite))
386 {
387 QString szErr;
388 szErr = tr("Failed to open SSH tunnel:");
389 szErr += "(" + m_pPara->m_Proxy.m_SSH.m_Net.GetHost();
390 szErr += ":";
391 szErr += QString::number(m_pPara->m_Proxy.m_SSH.m_Net.GetPort());
392 szErr += " - ";
393 szErr += m_pPara->m_Net.GetHost();
394 szErr += ":";
395 szErr += QString::number(m_pPara->m_Net.GetPort()) + ")";
396 QString szMsg = szErr + "\n" + channel->errorString();
397 emit sigShowMessageBox(tr("Error"), szMsg, QMessageBox::Critical);
398 return -2;
399 }
400 m_SecurityLevel = CSecurityLevel::Level::Proxy;
401#endif
402 return 0;
403}
404
405int CBackendVnc::SetChannelConnect(QSharedPointer<CChannel> channel)
406{
407 bool check = false;
408 check = connect(channel.data(), SIGNAL(sigConnected()),
409 this, SLOT(slotConnected()));
410 Q_ASSERT(check);
411 check = connect(channel.data(), SIGNAL(sigDisconnected()),
412 this, SLOT(slotDisConnected()));
413 Q_ASSERT(check);
414 check = connect(channel.data(), SIGNAL(readyRead()),
415 this, SLOT(slotReadyRead()));
416 Q_ASSERT(check);
417 check = connect(channel.data(), SIGNAL(sigError(int, const QString&)),
418 this, SLOT(slotChannelError(int, const QString&)));
419 Q_ASSERT(check);
420 if(m_pOperate && m_pOperate->GetStats()) {
421 check = connect(channel.data(), SIGNAL(sigReceive(quint64)),
422 m_pOperate->GetStats(), SLOT(AddReceives(quint64)));
423 Q_ASSERT(check);
424 check = connect(channel.data(), SIGNAL(sigSend(quint64)),
425 m_pOperate->GetStats(), SLOT(AddSends(quint64)));
426 Q_ASSERT(check);
427 }
428 return 0;
429}
430
431int CBackendVnc::OnClean()
432{
433 qDebug(log) << "CConnectVnc::OnClean()";
434 close();
435 setStreams(nullptr, nullptr);
436 if(m_DataChannel) {
437 m_DataChannel->close();
438 }
439 emit sigFinished();
440 return 0;
441}
442
456int CBackendVnc::OnProcess()
457{
458 int nRet = 0;
459#ifdef HAVE_LIBSSH
460 if(m_pPara->m_Proxy.GetUsedType() == CParameterProxy::TYPE::SSHTunnel) {
461 CChannelSSHTunnel* channel = (CChannelSSHTunnel*)m_DataChannel.data();
462 if(channel)
463 nRet = channel->Process();
464 }
465#endif
466
467 return nRet;
468}
469
470int CBackendVnc::WakeUp()
471{
472#ifdef HAVE_LIBSSH
473 if(m_pPara->m_Proxy.GetUsedType() == CParameterProxy::TYPE::SSHTunnel) {
474 CChannelSSHTunnel* channel = (CChannelSSHTunnel*)m_DataChannel.data();
475 if(channel)
476 channel->WakeUp();
477 }
478#endif
479 return 0;
480}
481
482void CBackendVnc::slotConnected()
483{
484 qDebug(log) << Q_FUNC_INFO;
485 if(m_pPara->GetIce())
486 qInfo(log) << "Connected to peer " + m_pPara->GetPeerUser();
487 else {
488 auto &net = m_pPara->m_Net;
489 QString szInfo = "Connected to "
490 + net.GetHost() + ":" + QString::number(net.GetPort());
491#ifdef HAVE_LIBSSH
492 if(CParameterProxy::TYPE::SSHTunnel == m_pPara->m_Proxy.GetUsedType())
493 {
494 auto &sshNet = m_pPara->m_Proxy.m_SSH.m_Net;
495 szInfo += " with ssh turnnel: " + sshNet.GetHost()
496 + ":" + QString::number(sshNet.GetPort());
497 }
498#endif
499 qInfo(log) << szInfo;
500 }
501 int nRet = SetPara();
502 if(nRet)
503 {
504 emit sigStop();
505 return;
506 }
507 m_InStream = QSharedPointer<rdr::InStream>(new CInStreamChannel(m_DataChannel.data()));
508 m_OutStream = QSharedPointer<rdr::OutStream>(new COutStreamChannel(m_DataChannel.data()));
509 if(!(m_InStream && m_OutStream))
510 {
511 qCritical(log) << "m_InStream or m_OutStream is null";
512 emit sigStop();
513 return;
514 }
515 setStreams(m_InStream.data(), m_OutStream.data());
516 initialiseProtocol();
517}
518
519void CBackendVnc::slotDisConnected()
520{
521 QString szInfo;
522 szInfo = "CConnectVnc::slotDisConnected() from "
523 + m_pPara->m_Net.GetHost() + ":"
524 + QString::number(m_pPara->m_Net.GetPort());
525#ifdef HAVE_LIBSSH
526 if(CParameterProxy::TYPE::SSHTunnel == m_pPara->m_Proxy.GetUsedType())
527 {
528 auto &net = m_pPara->m_Proxy.m_SSH.m_Net;
529 szInfo += " with ssh turnnel: " + net.GetHost()
530 + ":" + QString::number(net.GetPort());
531 }
532#endif
533 qInfo(log) << szInfo;
534}
535
536void CBackendVnc::slotReadyRead()
537{
538 //qDebug(log) << "CConnectVnc::slotReadyRead";
539 QString szErr("processMsg exception: ");
540 int nRet = -1;
541 try {
542 getOutStream()->flush();
543
544 getOutStream()->cork(true);
545 while(processMsg())
546 ;
547 getOutStream()->cork(false);
548 return;
549 } catch (rfb::AuthFailureException& e) {
550 szErr = tr("Logon to ");
551 szErr += m_pPara->m_Net.GetHost();
552 szErr += ":";
553 szErr += QString::number(m_pPara->m_Net.GetPort());
554 szErr += tr(" fail.");
555 QString szMsg = szErr + "\n" + tr("Please check that the username and password are correct.") + "\n";
556 emit sigShowMessageBox(tr("Error"), szMsg, QMessageBox::Critical);
557
558 szErr += " [";
559 szErr += e.str();
560 szErr += "]";
561 } catch (rfb::ConnFailedException& e) {
562 QString szErr;
563 szErr = tr("Connect to ");
564 szErr += m_pPara->m_Net.GetHost();
565 szErr += ":";
566 szErr += QString::number(m_pPara->m_Net.GetPort());
567 szErr += tr(" fail.");
568 szErr += " [";
569 szErr += e.str();
570 szErr += "]";
571 emit sigShowMessageBox(tr("Error"), szErr, QMessageBox::Critical);
572 } catch (rdr::EndOfStream& e) {
573 szErr += e.str();
574 } catch(rdr::GAIException &e) {
575 nRet = e.err;
576 szErr += "[" + QString::number(e.err) + "] " + e.str();
577 } catch(rdr::SystemException &e) {
578 nRet = e.err;
579 szErr += "[" + QString::number(e.err) + "] " + e.str();
580 } catch (rdr::Exception& e) {
581 szErr += e.str();
582 } catch (std::exception &e) {
583 szErr += e.what();
584 } catch(...) {
585 szErr += "unknown exception";
586 }
587 qCritical(log) << szErr;
588 emit sigError(nRet, szErr);
589 emit sigStop();
590}
591
592void CBackendVnc::slotChannelError(int nErr, const QString& szErr)
593{
594 qDebug(log) << "Channel error:" << nErr << "-" << szErr;
595 emit sigError(nErr, szErr);
596 emit sigStop();
597}
598
599// initDone() is called when the serverInit message has been received. At
600// this point we create the desktop window and display it. We also tell the
601// server the pixel format and encodings to use and request the first update.
602void CBackendVnc::initDone()
603{
604 Q_ASSERT(m_pPara);
605 qDebug(log, "initDone: %s", ConnectInformation().toStdString().c_str());
606
607 emit sigSetDesktopSize(server.width(), server.height());
608 QString szName = QString::fromUtf8(server.name());
609 emit sigServerName(szName);
610
611 //Set viewer frame buffer
612 setFramebuffer(new CFramePixelBuffer(server.width(), server.height()));
613
614 // Force a switch to the format and encoding we'd like
615 // Set Preferred Encoding
616 setPreferredEncoding(m_pPara->GetPreferredEncoding());
617 updatePixelFormat();
618
619 emit sigSecurityLevel(m_SecurityLevel);
620 emit sigRunning();
621}
622
623void CBackendVnc::resizeFramebuffer()
624{
625 rfb::ModifiablePixelBuffer* buffer = getFramebuffer();
626
627 qDebug(log) << "CConnectVnc::resizeFramebuffer: new:"
628 << server.width() << server.height()
629 << "old:" << buffer->width() << buffer->height();
630
631 if(server.width() == buffer->width() && server.height() == buffer->height())
632 return;
633
634 //Set viewer frame buffer
635 setFramebuffer(new CFramePixelBuffer(server.width(), server.height()));
636 emit sigSetDesktopSize(server.width(), server.height());
637}
638
639void CBackendVnc::setColourMapEntries(int firstColour, int nColours, uint16_t *rgbs)
640{
641 qCritical(log) << "Invalid SetColourMapEntries from server!";
642}
643
644void CBackendVnc::bell()
645{
646 qApp->beep();
647}
648
649void CBackendVnc::setLEDState(unsigned int state)
650{
651 qDebug(log) << "CConnectVnc::setLEDState" << state;
652 CConnection::setLEDState(state);
653 emit sigUpdateLedState(state);
654}
655
656void CBackendVnc::setCursor(int width, int height, const rfb::Point &hotspot, const uint8_t *data)
657{
658 //qDebug(log) << "CConnectVnc::setCursor x:" << hotspot.x << ";y:" << hotspot.y;
659 if ((width == 0) || (height == 0)) {
660 QImage cursor(1, 1, QImage::Format_ARGB32);
661 uint8_t *buffer = cursor.bits();
662 memset(buffer, 0, 4);
663 emit sigUpdateCursor(QCursor(QPixmap::fromImage(cursor), hotspot.x, hotspot.y));
664 } else {
665 QImage cursor(width, height, QImage::Format_ARGB32);
666 uint8_t *buffer = cursor.bits();
667 memcpy(buffer, data, width * height * 4);
668 emit sigUpdateCursor(QCursor(QPixmap::fromImage(cursor), hotspot.x, hotspot.y));
669 }
670}
671
672void CBackendVnc::setCursorPos(const rfb::Point &pos)
673{
674 //qDebug(log) << "CConnectVnc::setCursorPos x:" << pos.x << ";y:" << pos.y;
675 emit sigUpdateCursorPosition(QPoint(pos.x, pos.y));
676}
677
678void CBackendVnc::fence(uint32_t flags, unsigned int len, const uint8_t data[])
679{
680 //qDebug(log, "CConnectVnc::fence:flags:0x%X; len:%d", flags, len);
681 CMsgHandler::fence(flags, len, data);
682 if (!(flags & rfb::fenceFlagRequest))
683 return;
684
685 // We handle everything synchronously so we trivially honor these modes
686 flags = flags & (rfb::fenceFlagBlockBefore | rfb::fenceFlagBlockAfter);
687 writer()->writeFence(flags, len, data);
688 return;
689}
690
691void CBackendVnc::getUserPasswd(bool secure, std::string *user, std::string *password)
692{
693 if(password)
694 {
695 auto &user = m_pPara->m_Net.m_User;
696 *password = user.GetPassword().toStdString();
697 if(user.GetPassword().isEmpty())
698 {
699 int nRet = QDialog::Rejected;
700 auto *net = &m_pPara->m_Net;
701 emit sigBlockShowWidget("CDlgUserPassword", nRet, net);
702 if(QDialog::Accepted == nRet)
703 {
704 *password = user.GetPassword().toStdString();
705 }
706 }
707 if(!password->empty())
708 m_SecurityLevel |= CSecurityLevel::Level::Authentication;
709 }
710}
711
712int CBackendVnc::getX509File(std::string *ca, std::string *crl)
713{
714 auto &user = m_pPara->m_Net.m_User;
715 if(ca)
716 *ca = user.GetCAFile().toStdString().c_str();
717 if(crl)
718 *crl = user.GetCRLFile().toStdString().c_str();
719 return 0;
720}
721
722bool CBackendVnc::showMsgBox(rfb::MsgBoxFlags flags, const char *title, const char *text)
723{
724 qDebug(log) << title << text;
725 QMessageBox::StandardButton nRet = QMessageBox::No;
726 QMessageBox::StandardButtons fgBtn = QMessageBox::No;
727 bool bCheckBox = 0;
728 if((int)flags & (int)rfb::MsgBoxFlags::M_OK)
729 fgBtn |= QMessageBox::Ok;
730
731 if((int)flags & (int)rfb::MsgBoxFlags::M_OKCANCEL)
732 fgBtn |= QMessageBox::Ok | QMessageBox::Cancel;
733 if((int)flags & (int)rfb::MsgBoxFlags::M_YESNO)
734 fgBtn |= QMessageBox::Yes | QMessageBox::No;
735
736 emit sigBlockShowMessageBox(QString(title), QString(text),
737 fgBtn, nRet, bCheckBox);
738 if(QMessageBox::Ok == nRet
739 || QMessageBox::Yes == nRet)
740 return true;
741 return false;
742}
743
744// setName() is called when the desktop name changes
745void CBackendVnc::setName(const char *name)
746{
747 qDebug(log) << "CConnectVnc::setName:" << name;
748 CConnection::setName(name);
749 QString szName = QString::fromUtf8(server.name());
750 emit sigServerName(szName);
751}
752
753// framebufferUpdateStart() is called at the beginning of an update.
754// Here we try to send out a new framebuffer update request so that the
755// next update can be sent out in parallel with us decoding the current
756// one.
757void CBackendVnc::framebufferUpdateStart()
758{
759 //qDebug(log) << "CConnectVnc::framebufferUpdateStart()";
760 CConnection::framebufferUpdateStart();
761}
762
763// framebufferUpdateEnd() is called at the end of an update.
764// For each rectangle, the FdInStream will have timed the speed
765// of the connection, allowing us to select format and encoding
766// appropriately, and then request another incremental update.
767void CBackendVnc::framebufferUpdateEnd()
768{
769 //qDebug(log) << "CConnectVnc::framebufferUpdateEnd()";
770 rfb::CConnection::framebufferUpdateEnd();
771
772 if(m_pPara /*&& m_pPara->GetBufferEndRefresh()*/)
773 {
774 const QImage& img = dynamic_cast<CFramePixelBuffer*>(getFramebuffer())->getImage();
775 emit sigUpdateRect(img);
776 }
777}
778
779// requestNewUpdate() requests an update from the server, having set the
780// format and encoding appropriately.
781void CBackendVnc::updatePixelFormat()
782{
783 Q_ASSERT(m_pPara);
784
785 if(!m_pPara) return;
786 rfb::PixelFormat pf;
787
788 switch (m_pPara->GetColorLevel()) {
789 case CParameterVnc::Full:
790 pf = fullColourPF;
791 break;
792 case CParameterVnc::Medium:
793 pf = mediumColourPF;
794 break;
795 case CParameterVnc::Low:
796 pf = lowColourPF;
797 break;
798 case CParameterVnc::VeryLow:
799 pf = verylowColourPF;
800 break;
801 }
802
803 char str[256];
804 pf.print(str, 256);
805 qInfo(log) << "Update pixel format:" << str;
806 setPF(pf);
807}
808
809void CBackendVnc::mousePressEvent(QMouseEvent *event)
810{
811 if(!writer()) return;
812 if(m_pPara && m_pPara->GetOnlyView()) return;
813
814 uint8_t mask = 0;
815 if(event->button() & Qt::MouseButton::LeftButton)
816 mask |= 0x1;
817 if(event->button() & Qt::MouseButton::MiddleButton)
818 mask |= 0x2;
819 if(event->button() & Qt::MouseButton::RightButton)
820 mask |= 0x4;
821 if(event->button() & Qt::MouseButton::BackButton)
822 mask |= 0x80;
823
824 QPoint pos = event->pos();
825 rfb::Point p(pos.x(), pos.y());
826
827 qDebug(logMouse) << Q_FUNC_INFO << event->buttons() << event->button() << pos << mask;
828
829 try{
830 writer()->writePointerEvent(p, mask);
831 } catch (rdr::Exception& e) {
832 emit sigError(-1, e.str());
833 }
834}
835
836void CBackendVnc::mouseReleaseEvent(QMouseEvent *event)
837{
838 if(!writer()) return;
839 if(m_pPara && m_pPara->GetOnlyView()) return;
840 uint8_t mask = 0;
841 QPoint pos = event->pos();
842 rfb::Point p(pos.x(), pos.y());
843 qDebug(logMouse) << Q_FUNC_INFO << event->buttons() << event->button() << pos << mask;
844 try{
845 writer()->writePointerEvent(p, mask);
846 } catch (rdr::Exception& e) {
847 emit sigError(-1, e.str());
848 }
849}
850
851void CBackendVnc::mouseMoveEvent(QMouseEvent *event)
852{
853 if(!writer()) return;
854 if(m_pPara && m_pPara->GetOnlyView()) return;
855
856 QPoint pos = event->pos();
857 rfb::Point p(pos.x(), pos.y());
858 uint8_t mask = 0;
859 if(event->buttons() & Qt::MouseButton::LeftButton)
860 mask |= 0x1;
861 if(event->buttons() & Qt::MouseButton::MiddleButton)
862 mask |= 0x2;
863 if(event->buttons() & Qt::MouseButton::RightButton)
864 mask |= 0x4;
865 if(event->buttons() & Qt::MouseButton::BackButton)
866 mask |= 0x80;
867
868 qDebug(logMouse) << Q_FUNC_INFO << event->buttons() << event->button() << pos << mask;
869
870 try{
871 writer()->writePointerEvent(p, mask);
872 } catch (rdr::Exception& e) {
873 emit sigError(-1, e.str());
874 }
875}
876
877// https://github.com/rfbproto/rfbproto/blob/master/rfbproto.rst#pointerevent
878void CBackendVnc::wheelEvent(QWheelEvent *event)
879{
880 if(!writer()) return;
881 if(m_pPara && m_pPara->GetOnlyView()) return;
882 uint8_t mask = 0;
883 if(event->buttons() & Qt::MouseButton::LeftButton)
884 mask |= 0x1;
885 if(event->buttons() & Qt::MouseButton::MiddleButton)
886 mask |= 0x2;
887 if(event->buttons() & Qt::MouseButton::RightButton)
888 mask |= 0x4;
889 if(event->buttons() & Qt::MouseButton::BackButton)
890 mask |= 0x80;
891
892 QPoint d = event->angleDelta();
893 if(d.y() > 0)
894 mask |= 0x8;
895 if(d.y() < 0)
896 mask |= 0x10;
897 if(d.x() < 0)
898 mask |= 0x20;
899 if(d.x() > 0)
900 mask |= 0x40;
901
902 QPointF pos;
903#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
904 pos = event->position();
905#else
906 pos = event->pos();
907#endif
908
909 rfb::Point p(pos.x(), pos.y());
910 //*
911 qDebug(logMouse) << Q_FUNC_INFO << event->buttons()
912#if QT_VERSION > QT_VERSION_CHECK(6, 0, 0)
913 << event->button()
914#endif
915 << pos << mask; //*/
916
917 try{
918 writer()->writePointerEvent(p, mask);
919 } catch (rdr::Exception& e) {
920 emit sigError(-1, e.str());
921 }
922}
923
924void CBackendVnc::keyPressEvent(QKeyEvent *event)
925{
926 if(!writer()) return;
927 if(m_pPara && m_pPara->GetOnlyView()) return;
928 bool modifier = false;
929 if (event->modifiers() & Qt::ShiftModifier)
930 modifier = true;
931
932 uint32_t k = TranslateRfbKey(event->key(), modifier);
933 qDebug(logKey) << Q_FUNC_INFO << event << k << modifier;
934
935 try{
936 writer()->writeKeyEvent(k, 0, true);
937 } catch (rdr::Exception& e) {
938 emit sigError(-1, e.str());
939 }
940}
941
942void CBackendVnc::keyReleaseEvent(QKeyEvent *event)
943{
944 if(m_pPara && m_pPara->GetOnlyView()) return;
945 if(!writer()) return;
946 bool modifier = false;
947 if (event->modifiers() & Qt::ShiftModifier)
948 modifier = true;
949
950 uint32_t k = TranslateRfbKey(event->key(), modifier);
951 qDebug(logKey) << Q_FUNC_INFO << event << k << modifier;
952
953 try{
954 writer()->writeKeyEvent(k, 0, false);
955 } catch (rdr::Exception& e) {
956 emit sigError(-1, e.str());
957 }
958}
959
960void CBackendVnc::InputMethodEvent(QInputMethodEvent *event)
961{
962}
963
964QString CBackendVnc::ConnectInformation()
965{
966 const int len = 128;
967 char buf[len];
968 QString szInfo;
969 szInfo = QString("Desktop name: ") + server.name() + "\n";
970 szInfo += QString("Size: %1 x %2").arg(server.width()).arg(server.height()) + "\n";
971
972 // TRANSLATORS: Will be filled in with a string describing the
973 // protocol pixel format in a fairly language neutral way
974 server.pf().print(buf, len);
975 szInfo += QString("Pixel format: ") + buf + "\n";
976 szInfo += QString("Requested encoding: ") + rfb::encodingName(getPreferredEncoding()) + "\n";
977 szInfo += QString("Protocol version: %1.%2").arg(server.majorVersion).arg(server.minorVersion) + "\n";
978 szInfo += QString("Security method: ") + rfb::secTypeName(csecurity->getType()) + "\n";
979 szInfo += QString("Support local cursor: %1").arg(supportsLocalCursor) + "\n";
980 szInfo += QString("Support cursor position: %1").arg(supportsCursorPosition) + "\n";
981 szInfo += QString("Support desktop resize: %1").arg(supportsDesktopResize) + "\n";
982 szInfo += QString("Support LED state: %1").arg(supportsLEDState) + "\n";
983 szInfo += QString("Led state: %1").arg(server.ledState()) + "\n";
984 szInfo += QString("Supports QEMU KeyEvent: %1").arg(server.supportsQEMUKeyEvent) + "\n";
985 szInfo += QString("Supports Set Desktop Size: %1").arg(server.supportsSetDesktopSize) + "\n";
986 szInfo += QString("Support fance: %1").arg(server.supportsFence) + "\n";
987 szInfo += QString("Support continue updates: %1").arg(server.supportsContinuousUpdates) + "\n";
988
989 return szInfo;
990}
991
999quint32 CBackendVnc::TranslateRfbKey(quint32 inkey, bool modifier)
1000{
1001 quint32 k = 5000;
1002
1003 switch (inkey)
1004 {
1005 case Qt::Key_Backspace: k = XK_BackSpace; break;
1006 case Qt::Key_Tab: k = XK_Tab; break;
1007 case Qt::Key_Clear: k = XK_Clear; break;
1008 case Qt::Key_Return: k = XK_Return; break;
1009 case Qt::Key_Pause: k = XK_Pause; break;
1010 case Qt::Key_Escape: k = XK_Escape; break;
1011 case Qt::Key_Space: k = XK_space; break;
1012 case Qt::Key_Delete: k = XK_Delete; break;
1013 case Qt::Key_Period: k = XK_period; break;
1014
1015 /* International & multi-key character composition */
1016 case Qt::Key_Multi_key: k = XK_Multi_key; break;
1017 case Qt::Key_Codeinput: k = XK_Codeinput; break;
1018 case Qt::Key_SingleCandidate: k = XK_SingleCandidate; break;
1019 case Qt::Key_MultipleCandidate: k = XK_MultipleCandidate; break;
1020 case Qt::Key_PreviousCandidate: k = XK_PreviousCandidate; break;
1021
1022 /* Japanese keyboard support */
1023 case Qt::Key_Kanji: k = XK_Kanji; break;
1024 case Qt::Key_Muhenkan: k = XK_Muhenkan; break;
1025 case Qt::Key_Henkan: k = XK_Henkan; break;
1026 case Qt::Key_Romaji: k = XK_Romaji; break;
1027 case Qt::Key_Hiragana: k = XK_Hiragana; break;
1028 case Qt::Key_Katakana: k = XK_Katakana; break;
1029 case Qt::Key_Hiragana_Katakana: k = XK_Hiragana_Katakana;break;
1030 case Qt::Key_Zenkaku: k = XK_Zenkaku; break;
1031 case Qt::Key_Hankaku: k = XK_Hankaku; break;
1032 case Qt::Key_Zenkaku_Hankaku: k = XK_Zenkaku_Hankaku; break;
1033 case Qt::Key_Touroku: k = XK_Touroku; break;
1034 case Qt::Key_Massyo: k = XK_Massyo; break;
1035 case Qt::Key_Kana_Lock: k = XK_Kana_Lock; break;
1036 case Qt::Key_Kana_Shift: k = XK_Kana_Shift; break;
1037 case Qt::Key_Eisu_Shift: k = XK_Eisu_Shift; break;
1038 case Qt::Key_Eisu_toggle: k = XK_Eisu_toggle; break;
1039
1040 //special keyboard char
1041 case Qt::Key_Exclam: k = XK_exclam; break;
1042 case Qt::Key_QuoteDbl: k = XK_quotedbl; break; //"
1043 case Qt::Key_NumberSign: k = XK_numbersign; break; //#
1044 case Qt::Key_Percent: k = XK_percent; break; //%
1045 case Qt::Key_Dollar: k = XK_dollar; break; //$
1046 case Qt::Key_Ampersand: k = XK_ampersand; break; //&
1047 case Qt::Key_Apostrophe: k = XK_apostrophe; break;
1048 case Qt::Key_ParenLeft: k = XK_parenleft; break; // (
1049 case Qt::Key_ParenRight: k = XK_parenright; break; // )
1050
1051 case Qt::Key_Slash: k = XK_slash; break; // /
1052 case Qt::Key_Asterisk: k = XK_asterisk; break; //*
1053 case Qt::Key_Minus: k = XK_minus; break; //-
1054 case Qt::Key_Plus: k = XK_plus; break; //+
1055 case Qt::Key_Enter: k = XK_Return; break; //
1056 case Qt::Key_Equal: k = XK_equal; break; //=
1057 case Qt::Key_Comma: return XK_comma; //,
1058
1059 case Qt::Key_Colon: k = XK_colon;break; // :
1060 case Qt::Key_Semicolon: k = XK_semicolon; break; //;
1061 case Qt::Key_Less: k = XK_less; break; // <
1062 case Qt::Key_Greater: k = XK_greater; break; // >
1063 case Qt::Key_Question: k = XK_question; break; //?
1064 case Qt::Key_At: k = XK_at; break; //@
1065
1066 case Qt::Key_BracketLeft: k = XK_bracketleft; break;
1067 case Qt::Key_Backslash: k = XK_backslash;break;
1068 case Qt::Key_BracketRight: k = XK_bracketright;break;
1069 case Qt::Key_AsciiCircum: k = XK_asciicircum;break;
1070 case Qt::Key_Underscore: k = XK_underscore;break;
1071 case Qt::Key_QuoteLeft: k = XK_quoteleft;break;
1072 case Qt::Key_BraceLeft: k = XK_braceleft;break;
1073 case Qt::Key_Bar: k = XK_bar; break;
1074 case Qt::Key_BraceRight: k = XK_braceright;break;
1075 case Qt::Key_AsciiTilde: k = XK_asciitilde;break;
1076 case Qt::Key_nobreakspace: k = XK_nobreakspace;break;
1077 case Qt::Key_exclamdown: k = XK_exclamdown;break;
1078 case Qt::Key_cent: k = XK_cent;break;
1079 case Qt::Key_sterling: k = XK_sterling;break;
1080 case Qt::Key_currency: k = XK_currency;break;
1081 case Qt::Key_yen: k = XK_yen;break;
1082 case Qt::Key_brokenbar: k = XK_brokenbar;break;
1083 case Qt::Key_section: k = XK_section;break;
1084 case Qt::Key_diaeresis: k = XK_diaeresis;break;
1085 case Qt::Key_copyright: k = XK_copyright; break;
1086 case Qt::Key_ordfeminine: k = XK_ordfeminine; break;
1087 case Qt::Key_guillemotleft: k = XK_guillemotleft; break;
1088 case Qt::Key_guillemotright: k = XK_guillemotright; break;
1089 case Qt::Key_notsign: k = XK_notsign; break;
1090 case Qt::Key_hyphen: k = XK_hyphen; break;
1091 case Qt::Key_registered: k = XK_registered; break;
1092
1093 case Qt::Key_Up: k = XK_Up; break;
1094 case Qt::Key_Down: k = XK_Down; break;
1095 case Qt::Key_Right: k = XK_Right; break;
1096 case Qt::Key_Left: k = XK_Left; break;
1097 case Qt::Key_Insert: k = XK_Insert; break;
1098 case Qt::Key_Home: k = XK_Home; break;
1099 case Qt::Key_End: k = XK_End; break;
1100 case Qt::Key_PageUp: k = XK_Page_Up; break;
1101 case Qt::Key_PageDown: k = XK_Page_Down; break;
1102 case Qt::Key_MediaPrevious: k = XK_Prior; break;
1103 case Qt::Key_MediaNext: k = XK_Next; break;
1104 case Qt::Key_MediaPlay: k = XK_Begin; break;
1105
1106 /* Misc Functions */
1107 case Qt::Key_Select: k = XK_Select; break;
1108 case Qt::Key_Printer: k = XK_Print; break;
1109 case Qt::Key_Execute: k = XK_Execute; break;
1110 case Qt::Key_Undo: k = XK_Undo; break;
1111 case Qt::Key_Redo: k = XK_Redo; break;
1112 case Qt::Key_Menu: k = XK_Menu; break;
1113 case Qt::Key_Find: k = XK_Find; break;
1114 case Qt::Key_Exit:
1115 case Qt::Key_Cancel:
1116 case Qt::Key_Stop:
1117 k = XK_Cancel;
1118 break;
1119 case Qt::Key_Mode_switch: k = XK_Mode_switch; break;
1120
1121 case Qt::Key_F1: k = XK_F1; break;
1122 case Qt::Key_F2: k = XK_F2; break;
1123 case Qt::Key_F3: k = XK_F3; break;
1124 case Qt::Key_F4: k = XK_F4; break;
1125 case Qt::Key_F5: k = XK_F5; break;
1126 case Qt::Key_F6: k = XK_F6; break;
1127 case Qt::Key_F7: k = XK_F7; break;
1128 case Qt::Key_F8: k = XK_F8; break;
1129 case Qt::Key_F9: k = XK_F9; break;
1130 case Qt::Key_F10: k = XK_F10; break;
1131 case Qt::Key_F11: k = XK_F11; break;
1132 case Qt::Key_F12: k = XK_F12; break;
1133 case Qt::Key_F13: k = XK_F13; break;
1134 case Qt::Key_F14: k = XK_F14; break;
1135 case Qt::Key_F15: k = XK_F15; break;
1136 case Qt::Key_F16: k = XK_F16; break;
1137 case Qt::Key_F17: k = XK_F17; break;
1138 case Qt::Key_F18: k = XK_F18; break;
1139 case Qt::Key_F19: k = XK_F19; break;
1140 case Qt::Key_F20: k = XK_F20; break;
1141 case Qt::Key_F21: k = XK_F21; break;
1142 case Qt::Key_F22: k = XK_F22; break;
1143 case Qt::Key_F23: k = XK_F23; break;
1144 case Qt::Key_F24: k = XK_F24; break;
1145 case Qt::Key_F25: k = XK_F25; break;
1146 case Qt::Key_F26: k = XK_F26; break;
1147 case Qt::Key_F27: k = XK_F27; break;
1148 case Qt::Key_F28: k = XK_F28; break;
1149 case Qt::Key_F29: k = XK_F29; break;
1150 case Qt::Key_F30: k = XK_F30; break;
1151 case Qt::Key_F31: k = XK_F31; break;
1152 case Qt::Key_F32: k = XK_F32; break;
1153 case Qt::Key_F33: k = XK_F33; break;
1154 case Qt::Key_F34: k = XK_F34; break;
1155 case Qt::Key_F35: k = XK_F35; break;
1156
1157 case Qt::Key_NumLock: k = XK_Num_Lock; break;
1158 case Qt::Key_CapsLock: k = XK_Caps_Lock; break;
1159 case Qt::Key_ScrollLock: k = XK_Scroll_Lock; break;
1160
1161 case Qt::Key_Shift: k = XK_Shift_R; break; //k = XK_Shift_L; break;
1162 case Qt::Key_Control: k = XK_Control_R; break;// k = XK_Control_L; break;
1163 case Qt::Key_Alt: k = XK_Alt_R; break;//k = XK_Alt_L; break;
1164 case Qt::Key_Meta: k = XK_Meta_R; break;//k = XK_Meta_L; break;*/
1165
1166 case Qt::Key_Super_L: k = XK_Super_L; break; /* left "windows" key */
1167 case Qt::Key_Super_R: k = XK_Super_R; break; /* right "windows" key */
1168
1169 case Qt::Key_Hyper_L: k = XK_Hyper_L; break;
1170 case Qt::Key_Hyper_R: k = XK_Hyper_R; break;
1171
1172 case Qt::Key_Help: k = XK_Help; break;
1173 case Qt::Key_Print: k = XK_Print; break;
1174 case Qt::Key_SysReq: k = XK_Sys_Req; break;
1175 case Qt::Key_0: k = XK_0;break;
1176 case Qt::Key_1: k = XK_1;break;
1177 case Qt::Key_2: k = XK_2;break;
1178 case Qt::Key_3: k = XK_3;break;
1179 case Qt::Key_4: k = XK_4;break;
1180 case Qt::Key_5: k = XK_5;break;
1181 case Qt::Key_6: k = XK_6;break;
1182 case Qt::Key_7: k = XK_7;break;
1183 case Qt::Key_8: k = XK_8;break;
1184 case Qt::Key_9: k = XK_9;break;
1185 }
1186
1187 if (k == 5000)
1188 {
1189
1190 if (!modifier)
1191 {
1192 switch (inkey)
1193 {
1194 case Qt::Key_A: k = XK_a;break;
1195 case Qt::Key_B: k = XK_b;break;
1196 case Qt::Key_C: k = XK_c;break;
1197 case Qt::Key_D: k = XK_d;break;
1198 case Qt::Key_E: k = XK_e;break;
1199 case Qt::Key_F: k = XK_f;break;
1200 case Qt::Key_G: k = XK_g;break;
1201 case Qt::Key_H: k = XK_h;break;
1202 case Qt::Key_I: k = XK_i;break;
1203 case Qt::Key_J: k = XK_j;break;
1204 case Qt::Key_K: k = XK_k;break;
1205 case Qt::Key_L: k = XK_l;break;
1206 case Qt::Key_M: k = XK_m;break;
1207 case Qt::Key_N: k = XK_n;break;
1208 case Qt::Key_O: k = XK_o;break;
1209 case Qt::Key_P: k = XK_p;break;
1210 case Qt::Key_Q: k = XK_q;break;
1211 case Qt::Key_R: k = XK_r;break;
1212 case Qt::Key_S: k = XK_s;break;
1213 case Qt::Key_T: k = XK_t;break;
1214 case Qt::Key_U: k = XK_u;break;
1215 case Qt::Key_V: k = XK_v;break;
1216 case Qt::Key_W: k = XK_w;break;
1217 case Qt::Key_X: k = XK_x;break;
1218 case Qt::Key_Y: k = XK_y;break;
1219 case Qt::Key_Z: k = XK_z;break;
1220 }
1221 }
1222 else
1223 {
1224 switch (inkey)
1225 {
1226 case Qt::Key_A: k = XK_A;break;
1227 case Qt::Key_B: k = XK_B;break;
1228 case Qt::Key_C: k = XK_C;break;
1229 case Qt::Key_D: k = XK_D;break;
1230 case Qt::Key_E: k = XK_E;break;
1231 case Qt::Key_F: k = XK_F;break;
1232 case Qt::Key_G: k = XK_G;break;
1233 case Qt::Key_H: k = XK_H;break;
1234 case Qt::Key_I: k = XK_I;break;
1235 case Qt::Key_J: k = XK_J;break;
1236 case Qt::Key_K: k = XK_K;break;
1237 case Qt::Key_L: k = XK_L;break;
1238 case Qt::Key_M: k = XK_M;break;
1239 case Qt::Key_N: k = XK_N;break;
1240 case Qt::Key_O: k = XK_O;break;
1241 case Qt::Key_P: k = XK_P;break;
1242 case Qt::Key_Q: k = XK_Q;break;
1243 case Qt::Key_R: k = XK_R;break;
1244 case Qt::Key_S: k = XK_S;break;
1245 case Qt::Key_T: k = XK_T;break;
1246 case Qt::Key_U: k = XK_U;break;
1247 case Qt::Key_V: k = XK_V;break;
1248 case Qt::Key_W: k = XK_W;break;
1249 case Qt::Key_X: k = XK_X;break;
1250 case Qt::Key_Y: k = XK_Y;break;
1251 case Qt::Key_Z: k = XK_Z;break;
1252 }
1253 }
1254 }
1255
1256 return k;
1257
1258}
1259
1260void CBackendVnc::slotClipBoardChanged()
1261{
1262 //qDebug(log) << "CConnectVnc::slotClipBoardChanged()";
1263 if(!m_pPara->GetClipboard() || !getOutStream() || !writer()) return;
1264 QClipboard* pClip = QApplication::clipboard();
1265 if(pClip->ownsClipboard()) return;
1266 announceClipboard(true);
1267}
1268
1269void CBackendVnc::handleClipboardRequest()
1270{
1271 //qDebug(log) << "CConnectVnc::handleClipboardRequest";
1272 if(!m_pPara->GetClipboard() || !getOutStream() || !writer()) return;
1273 const QClipboard *clipboard = QApplication::clipboard();
1274 const QMimeData *mimeData = clipboard->mimeData();
1275
1276 /*if (mimeData->hasImage()) {
1277 // setPixmap(qvariant_cast<QPixmap>(mimeData->imageData()));
1278 } else */if (mimeData->hasText()) {
1279 QString szText = mimeData->text();
1280 qDebug(log)
1281 << "CConnectVnc::handleClipboardRequest:szText:" << szText;
1282 try{
1283 sendClipboardData(szText.toStdString().c_str());
1284 } catch (rdr::Exception& e) {
1285 qCritical(log) << "sendClipboardData exception" << e.str();
1286 }
1287 } /*else if (mimeData->hasHtml()) {
1288 QString szHtml = mimeData->html();
1289 qDebug(log)
1290 << "CConnectVnc::handleClipboardRequest:html:" << szHtml;
1291 try{
1292 sendClipboardData(mimeData->html().toStdString().c_str());
1293 } catch (rdr::Exception& e) {
1294 qCritical(log) << "sendClipboardData exception" << e.str();
1295 }
1296 }*/ else {
1297 qCritical(log) << "Cannot display data";
1298 }
1299}
1300
1301void CBackendVnc::handleClipboardAnnounce(bool available)
1302{
1303 //qDebug(log) << "CConnectVnc::handleClipboardAnnounce";
1304 if(!m_pPara->GetClipboard() || !getOutStream() || !writer()) return;
1305 if(available)
1306 this->requestClipboard();
1307}
1308
1309void CBackendVnc::handleClipboardData(const char *data)
1310{
1311 //qDebug(log) << "CConnectVnc::handleClipboardData";
1312 if(!m_pPara->GetClipboard() || !getOutStream() || !writer()) return;
1313
1314 QMimeData* pData = new QMimeData();
1315 pData->setText(QString::fromUtf8(data));
1316 emit sigSetClipboard(pData);
1317}
1318
1319void CBackendVnc::authSuccess()
1320{
1321 qDebug(log) << "CConnectVnc::authSuccess";
1322}
CBackendDesktop
远程桌面接口。它由协议插件实现。
定义 BackendDesktop.h:38
CBackendDesktop::sigUpdateRect
void sigUpdateRect(const QRect &r, const QImage &image)
通知视图，图像更新
CBackendDesktop::slotClipBoardChanged
virtual void slotClipBoardChanged()=0
当剪切板发生改变时调用
CBackendVnc::TranslateRfbKey
quint32 TranslateRfbKey(quint32 inkey, bool modifier)
CBackendVnc::TranslateRfbKey
定义 BackendVnc.cpp:999
CBackendVnc::OnClean
virtual int OnClean() override
清理
定义 BackendVnc.cpp:431
CBackendVnc::WakeUp
virtual int WakeUp() override
唤醒后台线程。
定义 BackendVnc.cpp:470
CBackendVnc::OnInit
virtual OnInitReturnValue OnInit() override
初始化
定义 BackendVnc.cpp:198
CBackendVnc::OnProcess
virtual int OnProcess() override
插件连接的具体操作处理。因为此插件是非Qt事件，所以在此函数中等待。
定义 BackendVnc.cpp:456
CBackend::sigStop
void sigStop()
需要通知用户停止时触发。仅由插件触发。 当从插件中需要停止时触发。例如：对端断开连接、重置连接或者连接出错。
CBackend::sigShowMessageBox
void sigShowMessageBox(const QString &szTitle, const QString &szMessage, const QMessageBox::Icon &icon=QMessageBox::Information)
从后台线程中触发在主线程中显示消息对话框(QMessageBox)，不阻塞后台线程
CBackend::sigError
void sigError(const int nError, const QString &szError=QString())
当有错误产生时触发
CBackend::sigBlockShowMessageBox
void sigBlockShowMessageBox(const QString &szTitle, const QString &szMessage, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton &nRet, bool &checkBox, QString checkBoxContext=QString())
阻塞后台线程，并在前台线程中显示消息对话框(QMessageBox)
CBackend::sigRunning
void sigRunning()
当插件开始成功后触发。仅由插件触发
CBackend::sigFinished
void sigFinished()
停止成功信号。仅由插件触发
CBackend::sigSecurityLevel
void sigSecurityLevel(CSecurityLevel::Levels level)
当安全级别改变时触发
CBackend::sigBlockShowWidget
void sigBlockShowWidget(const QString &className, int &nRet, void *pContext)
阻塞后台线程，并在前台线程中显示窗口。
CChannel::CChannel
CChannel(QTcpSocket *pSocket, QObject *parent=nullptr)
CChannel
定义 Channel.cpp:19
CICE::Instance
static CICE * Instance()
Single instance
定义 Ice.cpp:55
CIceSignal
ICE 信令接口类
定义 IceSignal.h:26
COperateDesktop
远程桌面操作接口
定义 OperateDesktop.h:69
COperateDesktop::GetParameter
virtual CParameterDesktop * GetParameter() const
Get parameter
定义 OperateDesktop.cpp:450
CParameterUser::TYPE::OnlyPasswordX509None
@ OnlyPasswordX509None
Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile
定义 ParameterUser.h:48
CSecurityLevel
安全级别
定义 Stats.h:97
作者：康林 (kl222@126.com)

版权所有(c) 康林工作室 保留所有权力