Rabbit Remote Control 0.1.0-bate4
Loading...
Searching...
No Matches
BackendFreeRDP.cpp
1// Author: Kang Lin <kl222@126.com>
2// https://learn.microsoft.com/zh-cn/windows-server/remote/remote-desktop-services/welcome-to-rds
3// X.509 Public Key Certificates: https://learn.microsoft.com/zh-cn/windows/win32/seccertenroll/about-x-509-public-key-certificates
4// Cryptography: https://learn.microsoft.com/zh-cn/windows/win32/seccrypto/cryptography-portal
5
6#undef PEN_FLAG_INVERTED
7#include "freerdp/client.h"
8#include "freerdp/client/channels.h"
9#include "freerdp/channels/rdpei.h"
10#include "freerdp/channels/rdpdr.h"
11#include "freerdp/channels/disp.h"
12#include "freerdp/channels/tsmf.h"
13#include "freerdp/channels/rdpsnd.h"
14#include "freerdp/client/encomsp.h"
15#include "freerdp/gdi/gfx.h"
16#include "freerdp/settings.h"
17#include "freerdp/locale/keyboard.h"
18#include "freerdp/channels/rdpgfx.h"
19#include "freerdp/channels/cliprdr.h"
20#include "freerdp/client/cmdline.h"
21#include "freerdp/gdi/video.h"
22#include "winpr/winsock.h"
23
24#include "BackendFreeRDP.h"
25#include "RabbitCommonTools.h"
26#include "ConvertKeyCode.h"
27
28#include <memory.h>
29#include <QDebug>
30#include <QApplication>
31#include <QScreen>
32#include <QSslCertificate>
33#include <QInputDialog>
34#include <QMutexLocker>
35#include <QPainter>
36#include <QPrinterInfo>
37#include <QSerialPort>
38#include <QSerialPortInfo>
39#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
40 #include <QSoundEffect>
41#else
42 #include <QSound>
43#endif
44
45#ifdef WINPR_HAVE_POLL_H
46#include <poll.h>
47#else
48#include <time.h>
49#if defined(Q_OS_WIN)
50#include <WinSock2.h>
51#else
52#include <sys/select.h>
53#endif
54#endif
55
56#if FREERDP_VERSION_MAJOR >= 3
57#include "ConnectLayerQTcpSocket.h"
58#ifdef HAVE_LIBSSH
59#include "ConnectLayerSSHTunnel.h"
60#endif
61#endif
62#include "Channel.h"
63
64static Q_LOGGING_CATEGORY(log, "FreeRDP.Connect")
65static Q_LOGGING_CATEGORY(logKey, "FreeRDP.Connect.Key")
66static Q_LOGGING_CATEGORY(logMouse, "FreeRDP.Connect.Mouse")
67
68CBackendFreeRDP::CBackendFreeRDP(COperateFreeRDP *pOperate)
69 : CBackendDesktop(pOperate)
70 , m_pOperate(pOperate)
71 , m_pContext(nullptr)
72 , m_pParameter(nullptr)
73 , m_ClipBoard(this)
74 , m_Cursor(this)
75 , m_writeEvent(nullptr)
76#if FREERDP_VERSION_MAJOR >= 3
77 , m_pConnectLayer(nullptr)
78#endif
79#ifdef HAVE_LIBSSH
80 , m_pThreadSSH(nullptr)
81#endif
82{
83 qDebug(log) << Q_FUNC_INFO;
84 m_pParameter = qobject_cast<CParameterFreeRDP*>(pOperate->GetParameter());
85 Q_ASSERT(m_pParameter);
86}
87
88CBackendFreeRDP::~CBackendFreeRDP()
89{
90 qDebug(log) << Q_FUNC_INFO;
91}
92
93/*
94 * \return
95 * \li OnInitReturnValue::Fail: error
96 * \li OnInitReturnValue::UseOnProcess: Use OnProcess (non-Qt event loop)
97 * \li OnInitReturnValue::NotUseOnProcess: Don't use OnProcess (qt event loop)
98 */
99CBackendFreeRDP::OnInitReturnValue CBackendFreeRDP::OnInit()
100{
101 qDebug(log) << Q_FUNC_INFO;
102 int nRet = 0;
103
104 m_writeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
105 if(!m_writeEvent) {
106 qCritical(log) << "CreateEvent failed";
107 return OnInitReturnValue::Fail;
108 }
109 ZeroMemory(&m_ClientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
110 m_ClientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION;
111 m_ClientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS);
112 //m_ClientEntryPoints.settings = m_pParameter->m_pSettings;
113 m_ClientEntryPoints.GlobalInit = cbGlobalInit;
114 m_ClientEntryPoints.GlobalUninit = cbGlobalUninit;
115 m_ClientEntryPoints.ClientNew = cbClientNew;
116 m_ClientEntryPoints.ClientFree = cbClientFree;
117 m_ClientEntryPoints.ClientStart = cbClientStart;
118 m_ClientEntryPoints.ClientStop = cbClientStop;
119 m_ClientEntryPoints.ContextSize = sizeof(ClientContext);
120
121 auto pRdpContext = freerdp_client_context_new(&m_ClientEntryPoints);
122 if(pRdpContext)
123 {
124 m_pContext = (ClientContext*)pRdpContext;
125 m_pContext->pThis = this;
126 } else {
127 qCritical(log) << "freerdp_client_context_new fail";
128 return OnInitReturnValue::Fail;
129 }
130
131 rdpSettings* settings = pRdpContext->settings;
132 if(!settings) {
133 qCritical(log) << "settings is null";
134 return OnInitReturnValue::Fail;
135 }
136
137 //*
138 // Initial FreeRDP default parameters.
139 // See: https://github.com/KangLin/RabbitRemoteControl/issues/27
140 // Set default parameters: FreeRDP_SupportGraphicsPipeline and FreeRDP_RemoteFxCodec
141 // See:
142 // - [[MS-RDPBCGR]: Remote Desktop Protocol: Basic Connectivity and Graphics Remoting](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdpbcgr/5073f4ed-1e93-45e1-b039-6e30c385867c)
143 // - [[MS-RDPRFX]: Remote Desktop Protocol: RemoteFX Codec Extension](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdprfx/62495a4a-a495-46ea-b459-5cde04c44549)
144 // - [[MS-RDPEGFX]: Remote Desktop Protocol: Graphics Pipeline Extension](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdpegfx/da5c75f9-cd99-450c-98c4-014a496942b0)
145 // https://www.cswamp.com/post/37
146 // Set connection parameters. See: FREERDP_API BOOL freerdp_set_connection_type(rdpSettings* settings, UINT32 type);
147 char* argv[]= {(char*)QApplication::applicationFilePath().toStdString().c_str()};
148 int argc = sizeof(argv) / sizeof(char*);
149 nRet = freerdp_client_settings_parse_command_line(settings, argc, argv, TRUE);
150 if (nRet)
151 {
152 nRet = freerdp_client_settings_command_line_status_print(settings, nRet, argc, argv);
153 return OnInitReturnValue::Fail;
154 } //*/
155
156#if FREERDP_VERSION_MAJOR >= 3
157 if (!stream_dump_register_handlers(pRdpContext,
158 CONNECTION_STATE_MCS_CREATE_REQUEST,
159 FALSE))
160 return OnInitReturnValue::Fail;
161#endif
162
163 auto &user = m_pParameter->m_Net.m_User;
164 if(!user.GetUser().isEmpty())
165 freerdp_settings_set_string(
166 settings, FreeRDP_Username,
167 user.GetUser().toStdString().c_str());
168 if(!user.GetPassword().isEmpty())
169 freerdp_settings_set_string(
170 settings, FreeRDP_Password,
171 user.GetPassword().toStdString().c_str());
172
173 freerdp_settings_set_bool(
174 settings, FreeRDP_RedirectClipboard, m_pParameter->GetClipboard());
175
176#if FREERDP_VERSION_MAJOR >= 3
177 bool bOnlyView = m_pParameter->GetOnlyView();
178 freerdp_settings_set_bool(
179 settings, FreeRDP_SuspendInput, bOnlyView);
180#endif
181
182 freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
183 m_pParameter->GetDesktopWidth());
184 freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
185 m_pParameter->GetDesktopHeight());
186 freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth,
187 m_pParameter->GetColorDepth());
188
189 freerdp_settings_set_bool(settings, FreeRDP_UseMultimon,
190 m_pParameter->GetUseMultimon());
191
192 if(m_pParameter->GetReconnectInterval()) {
193 freerdp_settings_set_bool(
194 settings, FreeRDP_AutoReconnectionEnabled, true);
195 freerdp_settings_set_uint32(
196 settings,
197 FreeRDP_AutoReconnectMaxRetries,
198 m_pParameter->GetReconnectInterval());
199 }
200 else
201 freerdp_settings_set_bool(
202 settings, FreeRDP_AutoReconnectionEnabled, false);
203
204 //*Load channel
205 RedirectionSound();
206 RedirectionMicrophone();
207 RedirectionDriver();
208 RedirectionPrinter();
209 RedirectionSerial();
210 //*/
211
212 // Set proxy
213 switch(m_pParameter->m_Proxy.GetUsedType())
214 {
215 case CParameterProxy::TYPE::System:
216 break;
217 case CParameterProxy::TYPE::Http:
218 case CParameterProxy::TYPE::SockesV5:
219 {
220 CParameterNet* net = &m_pParameter->m_Proxy.m_SockesV5;
221 if (!freerdp_settings_set_uint32(settings, FreeRDP_ProxyType, PROXY_TYPE_SOCKS))
222 return OnInitReturnValue::Fail;
223 if(CParameterProxy::TYPE::Http == m_pParameter->m_Proxy.GetUsedType()) {
224 net = &m_pParameter->m_Proxy.m_Http;
225 if (!freerdp_settings_set_uint32(settings, FreeRDP_ProxyType, PROXY_TYPE_HTTP))
226 return OnInitReturnValue::Fail;
227 }
228 auto &user = net->m_User;
229 if (!freerdp_settings_set_string(settings, FreeRDP_ProxyHostname,
230 net->GetHost().toStdString().c_str()))
231 return OnInitReturnValue::Fail;
232 if (!freerdp_settings_set_uint16(settings, FreeRDP_ProxyPort, net->GetPort()))
233 return OnInitReturnValue::Fail;
234
235 if(((user.GetUsedType() == CParameterUser::TYPE::UserPassword)
236 && (user.GetPassword().isEmpty() || user.GetUser().isEmpty()))
237 || ((user.GetUsedType() == CParameterUser::TYPE::PublicKey)
238 && user.GetPassphrase().isEmpty())) {
239 int nRet = QDialog::Rejected;
240 emit sigBlockShowWidget("CDlgUserPassword", nRet, net);
241 if(QDialog::Accepted != nRet)
242 {
243 return OnInitReturnValue::Fail;
244 }
245 }
246 if (!freerdp_settings_set_string(settings, FreeRDP_ProxyUsername,
247 user.GetUser().toStdString().c_str()))
248 return OnInitReturnValue::Fail;
249 if (!freerdp_settings_set_string(settings, FreeRDP_ProxyPassword,
250 user.GetPassword().toStdString().c_str()))
251 return OnInitReturnValue::Fail;
252 /*
253#if FREERDP_VERSION_MAJOR >= 3
254 m_pConnectLayer = new CConnectLayerQTcpSocket(this);
255 if(!m_pConnectLayer) return OnInitReturnValue::Fail;
256 nRet = m_pConnectLayer->Initialize(pRdpContext);
257 if(nRet) return OnInitReturnValue::Fail;
258 return OnInitReturnValue::NotUseOnProcess;
259#endif
260*/
261 }
262 case CParameterProxy::TYPE::None:
263 {
264 if(!m_pParameter->GetDomain().isEmpty())
265 freerdp_settings_set_string(
266 settings, FreeRDP_Domain,
267 m_pParameter->GetDomain().toStdString().c_str());
268 if(m_pParameter->m_Net.GetHost().isEmpty())
269 {
270 QString szErr;
271 szErr = tr("The server is empty, please input it");
272 qCritical(log) << szErr;
273 emit sigShowMessageBox(tr("Error"), szErr, QMessageBox::Critical);
274 emit sigError(-1, szErr.toStdString().c_str());
275 return OnInitReturnValue::Fail;
276 }
277 auto &net = m_pParameter->m_Net;
278 freerdp_settings_set_string(
279 settings, FreeRDP_ServerHostname,
280 net.GetHost().toStdString().c_str());
281 freerdp_settings_set_uint32(
282 settings, FreeRDP_ServerPort,
283 net.GetPort());
284
285 nRet = freerdp_client_start(pRdpContext);
286 if(nRet)
287 {
288 qCritical(log) << "freerdp_client_start fail";
289 return OnInitReturnValue::Fail;
290 }
291 break;
292 }
293#ifdef HAVE_LIBSSH
294 case CParameterProxy::TYPE::SSHTunnel:
295 {
296#if FREERDP_VERSION_MAJOR >= 3
297 m_pConnectLayer = new ConnectLayerSSHTunnel(this);
298 if(!m_pConnectLayer) return OnInitReturnValue::Fail;
299 nRet = m_pConnectLayer->Initialize(pRdpContext);
300 if(nRet) return OnInitReturnValue::Fail;
301 break;
302#endif
303 return InitSSHTunnelPipe();
304 }
305#endif // HAVE_LIBSSH
306
307 default:
308 qCritical(log) << "Don't support proxy type:" << m_pParameter->m_Proxy.GetUsedType();
309 break;
310 };
311
312 return OnInitReturnValue::UseOnProcess;
313}
314
315int CBackendFreeRDP::OnClean()
316{
317 qDebug(log) << Q_FUNC_INFO;
318 int nRet = 0;
319 if(m_writeEvent)
320 {
321 CloseHandle(m_writeEvent);
322 m_writeEvent = nullptr;
323 }
324 if(m_pContext)
325 {
326 rdpContext* pRdpContext = (rdpContext*)m_pContext;
327 if(!freerdp_disconnect(pRdpContext->instance))
328 qCritical(log) << "freerdp_disconnect fail";
329
330 if(freerdp_client_stop(pRdpContext))
331 qCritical(log) << "freerdp_client_stop fail";
332
333 freerdp_client_context_free(pRdpContext);
334 m_pContext = nullptr;
335 }
336
337#if FREERDP_VERSION_MAJOR >= 3
338 if(m_pConnectLayer) {
339 m_pConnectLayer->Clean();
340 m_pConnectLayer->deleteLater();
341 m_pConnectLayer = nullptr;
342 }
343#endif
344
345#ifdef HAVE_LIBSSH
346 CleanSSHTunnelPipe();
347#endif
348
349 return nRet;
350}
351
365int CBackendFreeRDP::OnProcess()
366{
367 return OnProcess(DEFAULT_TIMEOUT);
368}
369
383int CBackendFreeRDP::OnProcess(int nTimeout)
384{
385 //qDebug(log) << Q_FUNC_INFO;
386 int nRet = 0;
387 HANDLE handles[64];
388 rdpContext* pRdpContext = (rdpContext*)m_pContext;
389
390 if(nullptr == freerdp_settings_get_string(pRdpContext->settings, FreeRDP_ServerHostname))
391 {
392 return 50;
393 }
394
395 do {
396 DWORD nCount = 0;
397
398 nCount += freerdp_get_event_handles(pRdpContext, &handles[nCount],
399 ARRAYSIZE(handles) - nCount);
400 if (nCount == 0)
401 {
402 qCritical(log) << "freerdp_get_event_handles failed";
403 nRet = -2;
404 break;
405 }
406
407 if(m_writeEvent)
408 handles[nCount++] = m_writeEvent;
409
410 DWORD waitStatus = WaitForMultipleObjects(nCount, handles, FALSE, nTimeout);
411
412 if(m_writeEvent)
413 ResetEvent(m_writeEvent);
414
415 if (waitStatus == WAIT_FAILED)
416 {
417 qCritical(log) << "WaitForMultipleObjects: WAIT_FAILED";
418 nRet = -2;
419 break;
420 }
421
422 if(waitStatus == WAIT_TIMEOUT)
423 {
424 //qDebug(log) << "WaitForMultipleObjects timeout";
425 nRet = 0;
426 break;
427 }
428
429 if (!freerdp_check_event_handles(pRdpContext))
430 {
431 nRet = -2;
432
433 UINT32 err = freerdp_get_last_error(pRdpContext);
434 QString szErr;
435 szErr = "freerdp_check_event_handles fail.";
436 szErr += " [";
437 szErr += QString::number(err);
438 szErr += " - ";
439 szErr += freerdp_get_last_error_category(err);
440 szErr += " - ";
441 szErr += freerdp_get_last_error_name(err);
442 szErr += "] ";
443 szErr += freerdp_get_last_error_string(err);
444 qCritical(log) << szErr;
445 emit sigError(err, szErr);
446
447 /* Reconnect
448 freerdp *instance = pRdpContext->instance;
449 if (client_auto_reconnect(instance))
450 {
451 nRet = 0;
452 break;
453 }
454
455 err = freerdp_get_last_error(pRdpContext);
456 szErr = "client_auto_reconnect[";
457 szErr += QString::number(err);
458 szErr += "]";
459 szErr += freerdp_get_last_error_category(err);
460 szErr += "-";
461 szErr += freerdp_get_last_error_name(err);
462 szErr += ":";
463 szErr += freerdp_get_last_error_string(err);
464 qCritical(log) << szErr;
465 emit sigError(err, szErr);//*/
466 }
467
468#if FREERDP_VERSION_MAJOR >= 3
469 if(freerdp_shall_disconnect_context(pRdpContext))
470#else
471 if(freerdp_shall_disconnect(pRdpContext->instance))
472#endif
473 {
474 qCritical(log) << "freerdp_shall_disconnect false";
475 nRet = -2;
476 }
477 } while(false);
478
479 return nRet;
480}
481
482void CBackendFreeRDP::slotClipBoardChanged()
483{
484 qDebug(log) << Q_FUNC_INFO;
485 if(m_pParameter && m_pParameter->GetOnlyView()) return;
486 if(m_pParameter->GetClipboard())
487 m_ClipBoard.slotClipBoardChanged();
488}
489
490BOOL CBackendFreeRDP::cbGlobalInit()
491{
492 qDebug(log) << Q_FUNC_INFO;
493 return TRUE;
494}
495
496void CBackendFreeRDP::cbGlobalUninit()
497{
498 qDebug(log) << Q_FUNC_INFO;
499}
500
501BOOL CBackendFreeRDP::cbClientNew(freerdp *instance, rdpContext *context)
502{
503 qDebug(log) << Q_FUNC_INFO;
504 instance->PreConnect = cb_pre_connect;
505 instance->PostConnect = cb_post_connect;
506 instance->PostDisconnect = cb_post_disconnect;
507
508 // Because it is already set in the parameters
509#if FREERDP_VERSION_MAJOR < 3
510 instance->Authenticate = cb_authenticate;
511 instance->GatewayAuthenticate = cb_GatewayAuthenticate;
512#else
513 instance->AuthenticateEx = cb_authenticate_ex;
514 instance->ChooseSmartcard = cb_choose_smartcard;
515#endif
516 instance->VerifyX509Certificate = cb_verify_x509_certificate;
517 instance->VerifyCertificateEx = cb_verify_certificate_ex;
518 instance->VerifyChangedCertificateEx = cb_verify_changed_certificate_ex;
519 instance->PresentGatewayMessage = cb_present_gateway_message;
520
521 instance->LogonErrorInfo = cb_logon_error_info;
522
523 return TRUE;
524}
525
526void CBackendFreeRDP::cbClientFree(freerdp *instance, rdpContext *context)
527{
528 qDebug(log) << Q_FUNC_INFO;
529}
530
531int CBackendFreeRDP::cbClientStart(rdpContext *context)
532{
533 qDebug(log) << Q_FUNC_INFO;
534 UINT32 nRet = 0;
535
536 if (!context || !context->settings)
537 return -1;
538 freerdp* instance = freerdp_client_get_instance(context);
539 if(!instance)
540 return -2;
541 CBackendFreeRDP* pThis = ((ClientContext*)context)->pThis;
542 auto settings = context->settings;
543
544 QString szDomainHost;
545 quint16 nPort;
546 szDomainHost = freerdp_settings_get_string(settings, FreeRDP_ServerHostname);
547 nPort = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
548 QString szServer;
549 auto &net = pThis->m_pParameter->m_Net;
550 szServer = net.GetHost() + ":" + QString::number(net.GetPort());
551 auto &proxy = pThis->m_pParameter->m_Proxy;
552 switch(proxy.GetUsedType()) {
553 case CParameterProxy::TYPE::SockesV5:
554 {
555 auto &sockesV5 = proxy.m_SockesV5;
556 szServer = sockesV5.GetHost() + ":" + QString::number(sockesV5.GetPort())
557 + " -> " + szServer;
558 break;
559 }
560 case CParameterProxy::TYPE::Http:
561 {
562 auto &http = proxy.m_Http;
563 szServer = http.GetHost() + ":" + QString::number(http.GetPort())
564 + " -> " + szServer;
565 break;
566 }
567 case CParameterProxy::TYPE::SSHTunnel:
568 {
569 auto &sshNet = proxy.m_SSH.m_Net;
570#if FREERDP_VERSION_MAJOR < 3
571 szServer = szDomainHost + ":" + QString::number(nPort)
572 + " -> " + sshNet.GetHost() + ":" + QString::number(sshNet.GetPort())
573 + " -> " + szServer;
574#else
575 szServer = sshNet.GetHost() + ":" + QString::number(sshNet.GetPort())
576 + " -> " + szServer;
577#endif
578 break;
579 }
580 default:
581 break;
582 }
583
584 BOOL status = freerdp_connect(instance);
585 if (status) {
586 QString szInfo = tr("Connected to ") + szServer;
587 qInfo(log) << szInfo;
588 emit pThis->sigInformation(szInfo);
589 } else {
590 //DWORD dwErrCode = freerdp_error_info(instance);
591 UINT32 nRet = freerdp_get_last_error(context);
592
593 QString szErr;
594 szErr = tr("Connect to ") + szServer + tr(" fail.");
595 szErr += "\n[";
596 szErr += QString::number(nRet) + " - ";
597 szErr += freerdp_get_last_error_name(nRet);
598 szErr += "] ";
599 /*szErr += "[";
600 szErr += freerdp_get_last_error_category(nRet);
601 szErr += "] ";*/
602 szErr += freerdp_get_last_error_string(nRet);
603 //szErr += "]";
604
605 switch(nRet) {
606 case FREERDP_ERROR_CONNECT_LOGON_FAILURE:
607 {
608 szErr = tr("Logon to ") + szServer;
609 szErr += tr(" fail. Please check that the username and password are correct.") + "\n";
610 break;
611 }
612 case FREERDP_ERROR_CONNECT_WRONG_PASSWORD:
613 {
614 szErr = tr("Logon to ") + szServer;
615 szErr += tr(" fail. Please check password are correct.") + "\n";
616 break;
617 }
618 case FREERDP_ERROR_AUTHENTICATION_FAILED:
619 {
620 szErr = tr("Logon to ") + szServer;
621 szErr += tr(" authentication fail. please add a CA certificate to the store.") + "\n";
622 break;
623 }
624 case FREERDP_ERROR_CONNECT_TRANSPORT_FAILED:
625 {
626 szErr = tr("Logon to ") + szServer;
627 szErr += tr(" connect transport layer fail.") + "\n\n";
628 szErr += tr("Please:") + "\n";
629 szErr += tr("1. Check for any network related issues") + "\n";
630 szErr += tr("2. Check you have proper security settings ('NLA' enabled is required for most connections nowadays)") + "\n";
631 szErr += " " + tr("If you do not know the server security settings, contact your server administrator.") + "\n";
632 szErr += tr("3. Check the certificate is proper (and guacd properly checks that)") + "\n";
633 break;
634 }
635 case FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED:
636 szErr += "\n\n";
637 szErr += tr("Please check you have proper security settings.") + "\n";
638 szErr += tr("If you do not know the server security settings, contact your server administrator.");
639 break;
640 case FREERDP_ERROR_CONNECT_CANCELLED:
641 szErr = tr("The connect was canceled.") + "\n\n" + szErr;
642 break;
643 default:
644 break;
645 }
646
647 emit pThis->sigShowMessageBox(tr("Error"), szErr, QMessageBox::Critical);
648 qCritical(log) << szErr;
649 emit pThis->sigError(nRet, szErr.toStdString().c_str());
650 }
651
652 return nRet;
653}
654
655int CBackendFreeRDP::cbClientStop(rdpContext *context)
656{
657 int nRet = 0;
658 qDebug(log) << Q_FUNC_INFO;
659#if FREERDP_VERSION_MAJOR >= 3
660 nRet = freerdp_client_common_stop(context);
661#else
662 BOOL bRet = freerdp_abort_connect(context->instance);
663 if(!bRet)
664 { qCritical(log) << "freerdp_abort_connect fail";
665 nRet = -1;
666 }
667#endif
668 return nRet;
669}
670
689BOOL CBackendFreeRDP::cb_pre_connect(freerdp* instance)
690{
691 qDebug(log) << Q_FUNC_INFO;
692 rdpChannels* channels = nullptr;
693 rdpSettings* settings = nullptr;
694 rdpContext* context = instance->context;
695
696 if (!instance || !instance->context || !instance->context->settings)
697 return FALSE;
698
699 CBackendFreeRDP* pThis = ((ClientContext*)context)->pThis;
700 if(!pThis) return FALSE;
701 settings = instance->context->settings;
702 channels = context->channels;
703 CParameterFreeRDP* pParameter = pThis->m_pParameter;
704 if(!channels || !pParameter)
705 return FALSE;
706
707 /* Optional OS identifier sent to server */
708#if defined (Q_OS_WIN)
709 if (!freerdp_settings_set_uint32(
710 settings, FreeRDP_OsMajorType, OSMAJORTYPE_WINDOWS))
711 return FALSE;
712 if (!freerdp_settings_set_uint32(
713 settings, FreeRDP_OsMinorType, OSMINORTYPE_WINDOWS_NT))
714 return FALSE;
715#elif defined(Q_OS_ANDROID)
716 if (!freerdp_settings_set_uint32(
717 settings, FreeRDP_OsMajorType, OSMAJORTYPE_ANDROID))
718 return FALSE;
719 if (!freerdp_settings_set_uint32(
720 settings, FreeRDP_OsMinorType, OSMINORTYPE_UNSPECIFIED))
721 return FALSE;
722#elif defined(Q_OS_IOS)
723 if (!freerdp_settings_set_uint32(
724 settings, FreeRDP_OsMajorType, OSMAJORTYPE_IOS))
725 return FALSE;
726 if (!freerdp_settings_set_uint32(
727 settings, FreeRDP_OsMinorType, OSMINORTYPE_UNSPECIFIED))
728 return FALSE;
729#elif defined (Q_OS_UNIX)
730 if (!freerdp_settings_set_uint32(
731 settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
732 return FALSE;
733 if (!freerdp_settings_set_uint32(
734 settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_XSERVER))
735 return FALSE;
736#else
737 if (!freerdp_settings_set_uint32(
738 settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNSPECIFIED))
739 return FALSE;
740 if (!freerdp_settings_set_uint32(
741 settings, FreeRDP_OsMinorType, OSMINORTYPE_UNSPECIFIED))
742 return FALSE;
743#endif
744
745 // Subscribe channel event
746 PubSub_SubscribeChannelConnected(instance->context->pubSub,
747 OnChannelConnectedEventHandler);
748 PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
749 OnChannelDisconnectedEventHandler);
750
751#if FREERDP_VERSION_MAJOR < 3
752 if (!freerdp_client_load_addins(channels, instance->context->settings))
753 return FALSE;
754#else
755 #if defined(Q_OS_LINUX) || (defined(Q_OS_WIN) && defined(WITH_WINDOWS_CERT_STORE))
756 if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
757 return FALSE;
758 #endif
759#endif
760
761 if(!freerdp_settings_set_bool(
762 settings, FreeRDP_NegotiateSecurityLayer,
763 pParameter->GetNegotiateSecurityLayer()))
764 return FALSE;
765 CParameterFreeRDP::Security security = pParameter->GetSecurity();
766 // [5.3 Standard RDP Security](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/8e8b2cca-c1fa-456c-8ecb-a82fc60b2322)
767 if(!freerdp_settings_set_bool(
768 settings, FreeRDP_RdpSecurity,
769 CParameterFreeRDP::Security::RDP & security))
770 return FALSE;
771 if (!freerdp_settings_set_bool(
772 settings, FreeRDP_UseRdpSecurityLayer,
773 CParameterFreeRDP::Security::RDP & security))
774 return FALSE;
775 // [5.4 Enhanced RDP Security](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/592a0337-dc91-4de3-a901-e1829665291d)
776 if(!freerdp_settings_set_bool(
777 settings, FreeRDP_TlsSecurity,
778 CParameterFreeRDP::Security::TLS & security))
779 return FALSE;
780 if(!freerdp_settings_set_bool(
781 settings, FreeRDP_NlaSecurity,
782 CParameterFreeRDP::Security::NLA & security))
783 return FALSE;
784 if(!freerdp_settings_set_bool(
785 settings, FreeRDP_ExtSecurity,
786 CParameterFreeRDP::Security::NLA_Ext & security))
787 return FALSE;
788#if FREERDP_VERSION_MAJOR >= 3
789 if(!freerdp_settings_set_bool(
790 settings, FreeRDP_AadSecurity,
791 CParameterFreeRDP::Security::RDSAAD & security))
792 return FALSE;
793 if(!freerdp_settings_set_bool(
794 settings, FreeRDP_RdstlsSecurity,
795 CParameterFreeRDP::Security::RDSTLS & security))
796 return FALSE;
797 freerdp_settings_set_uint16(settings, FreeRDP_TLSMinVersion,
798 pParameter->GetTlsVersion());
799#endif
800
801 // Check authentication parameters
802 if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
803 {
804 /* Check +auth-only has a username and password. */
805 auto &user = pParameter->m_Net.m_User;
806 if(!freerdp_settings_get_string(settings, FreeRDP_Username)) {
807 if(user.GetUser().isEmpty()) {
808 // Will be call instance->Authenticate = cb_authenticate
809 qWarning(log) << "Auth-only, but no user name set. Will be call instance->Authenticate.";
810 } else
811 freerdp_settings_set_string(
812 settings, FreeRDP_Username,
813 user.GetUser().toStdString().c_str());
814 }
815 if (!freerdp_settings_get_string(settings, FreeRDP_Password)) {
816 if (user.GetPassword().isEmpty()) {
817 // Will be call instance->Authenticate = cb_authenticate
818 qWarning(log) << "auth-only, but no password set. Will be call instance->Authenticate";
819 } else
820 freerdp_settings_set_string(
821 settings, FreeRDP_Password,
822 user.GetPassword().toStdString().c_str());
823 }
824#if FREERDP_VERSION_MAJOR >= 3
825 if (!freerdp_settings_set_bool(settings, FreeRDP_DeactivateClientDecoding, TRUE))
826 return FALSE;
827#endif
828 } else if(freerdp_settings_get_bool(settings, FreeRDP_CredentialsFromStdin)){
829 // Because the pragram is GUI. so don't process it.
830 } else if(freerdp_settings_get_bool(settings, FreeRDP_SmartcardLogon)) {
831 // TODO: add FreeRDP_SmartcardLogon !
832 }
833
834 /* TODO: Check Keyboard layout
835 UINT32 rc = freerdp_keyboard_init(
836 freerdp_settings_get_uint32(settings, FreeRDP_KeyboardLayout));
837 freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, rc);
838 //*/
839
840 // Check desktop size, it is set in parameter
841 UINT32 width = pParameter->GetDesktopWidth();
842 UINT32 height = pParameter->GetDesktopHeight();
843 if ((width < 64) || (height < 64) ||
844 (width > 4096) || (height > 4096))
845 {
846 QString szErr = tr("Invalid dimensions:")
847 + QString::number(width)
848 + "*" + QString::number(height);
849 qCritical(log) << szErr;
850 //emit pThis->sigShowMessageBox(tr("Error"), szErr);
851 return FALSE;
852 } else {
853 qInfo(log) << "Init desktop size " << width << "*" << height;
854 }
855
856 qDebug(log)
857 << "width:" << freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth)
858 << "height:" << freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)
859 << "ColorDepth:" << freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
860
861 // Initial FreeRDP graph codec
862 // See: https://github.com/KangLin/RabbitRemoteControl/issues/27
863 // Set default parameters FreeRDP_SupportGraphicsPipeline and FreeRDP_RemoteFxCodec in auto detec connect type
864 // See:
865 // - [[MS-RDPBCGR]: Remote Desktop Protocol: Basic Connectivity and Graphics Remoting](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdpbcgr/5073f4ed-1e93-45e1-b039-6e30c385867c)
866 // - [[MS-RDPRFX]: Remote Desktop Protocol: RemoteFX Codec Extension](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdprfx/62495a4a-a495-46ea-b459-5cde04c44549)
867 // - [[MS-RDPEGFX]: Remote Desktop Protocol: Graphics Pipeline Extension](https://learn.microsoft.com/zh-cn/openspecs/windows_protocols/ms-rdpegfx/da5c75f9-cd99-450c-98c4-014a496942b0)
868 // https://www.cswamp.com/post/37
869 // - [Remote Desktop Protocol (RDP) 10 AVC/H.264 improvements in Windows 10 and Windows Server 2016 Technical Preview](https://techcommunity.microsoft.com/blog/microsoft-security-blog/remote-desktop-protocol-rdp-10-avch-264-improvements-in-windows-10-and-windows-s/249588)
870 if(!freerdp_set_connection_type(settings, pParameter->GetConnectType()))
871 return FALSE;
872 freerdp_settings_set_uint32(
873 settings, FreeRDP_PerformanceFlags, pParameter->GetPerformanceFlags());
874 freerdp_performance_flags_split(settings);
875
876 freerdp_settings_set_bool(settings, FreeRDP_UnicodeInput, pParameter->GetEnableLocalInputMethod());
877 return TRUE;
878}
879
880const char* CBackendFreeRDP::GetTitle(freerdp* instance)
881{
882 const char* windowTitle;
883 UINT32 port;
884 BOOL addPort;
885 const char* name = nullptr;
886
887 CBackendFreeRDP* pThis = ((ClientContext*)instance->context)->pThis;
888 rdpSettings* settings = instance->context->settings;
889
890 if (!settings)
891 return nullptr;
892
893 windowTitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
894 if (windowTitle)
895 return windowTitle;
896
897#if FREERDP_VERSION_MAJOR >= 3
898 name = freerdp_settings_get_server_name(settings);
899#else
900 name = pThis->m_pParameter->m_Net.GetHost().toStdString().c_str();
901#endif
902 port = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
903
904 addPort = (port != 3389);
905
906 char buffer[MAX_PATH + 64] = { 0 };
907
908 if (!addPort)
909 sprintf_s(buffer, sizeof(buffer), "%s", name);
910 else
911 sprintf_s(buffer, sizeof(buffer), "%s:%" PRIu32, name, port);
912
913 freerdp_settings_set_string(settings, FreeRDP_WindowTitle, buffer);
914 return freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
915}
916
922BOOL CBackendFreeRDP::cb_post_connect(freerdp* instance)
923{
924 qDebug(log) << Q_FUNC_INFO;
925
926 rdpContext* context = instance->context;
927 rdpSettings* settings = instance->context->settings;
928 rdpUpdate* update = instance->context->update;
929 CBackendFreeRDP* pThis = ((ClientContext*)instance->context)->pThis;
930
931 const char* pWindowTitle = GetTitle(instance);
932 if(pWindowTitle)
933 {
934 WCHAR* windowTitle = NULL;
935#if FREERDP_VERSION_MAJOR >= 3
936 windowTitle = ConvertUtf8ToWCharAlloc(pWindowTitle, NULL);
937#else
938 ConvertToUnicode(CP_UTF8, 0, pWindowTitle, -1, &windowTitle, 0);
939#endif
940 if(windowTitle)
941 {
942 QString title = QString::fromUtf16((const char16_t*)windowTitle);
943 delete windowTitle;
944 if(pThis->m_pParameter->GetServerName().isEmpty())
945 emit pThis->sigServerName(title);
946 }
947 }
948
949 int desktopWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
950 int desktopHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
951 emit pThis->sigSetDesktopSize(desktopWidth, desktopHeight);
952
953 if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
954 return FALSE;
955
956 if(!pThis->CreateImage(instance->context))
957 return FALSE;
958
959 Q_ASSERT(instance->context->cache);
960
961 // Register cursor pointer
962 if(pThis->m_Cursor.RegisterPointer(context->graphics))
963 return FALSE;
964
965 update->BeginPaint = cb_begin_paint;
966 update->EndPaint = cb_end_paint;
967 update->DesktopResize = cb_desktop_resize;
968
969 update->PlaySound = cb_play_bell_sound;
970
971 update->SetKeyboardIndicators = cb_keyboard_set_indicators;
972 update->SetKeyboardImeStatus = cb_keyboard_set_ime_status;
973
974 emit pThis->sigRunning();
975 return TRUE;
976}
977
978void CBackendFreeRDP::cb_post_disconnect(freerdp* instance)
979{
980 qDebug(log) << Q_FUNC_INFO;
981 rdpContext* context = nullptr;
982
983 if (!instance || !instance->context)
984 return;
985
986 context = instance->context;
987
988 PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
989 OnChannelConnectedEventHandler);
990 PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
991 OnChannelDisconnectedEventHandler);
992 gdi_free(instance);
993}
994
995int CBackendFreeRDP::cb_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
996{
997 CBackendFreeRDP* pThis = ((ClientContext*)instance->context)->pThis;
998 const char* str_data = freerdp_get_logon_error_info_data(data);
999 const char* str_type = freerdp_get_logon_error_info_type(type);
1000 QString szErr = tr("FreeRDP logon info: [");
1001 szErr += str_type;
1002 szErr += "] ";
1003 szErr += str_data;
1004 qDebug(log) << szErr;
1005 emit pThis->sigInformation(szErr);
1006 emit pThis->sigError(type, szErr);
1007 return 1;
1008}
1009
1010void CBackendFreeRDP::OnChannelConnectedEventHandler(void *context,
1011 #if FREERDP_VERSION_MAJOR >= 3
1012 const
1013 #endif
1014 ChannelConnectedEventArgs *e)
1015{
1016 rdpContext* pContext = (rdpContext*)context;
1017 CBackendFreeRDP* pThis = ((ClientContext*)context)->pThis;
1018 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0) {
1019 qDebug(log) << "channel" << e->name << "connected";
1020 pThis->m_ClipBoard.Init((CliprdrClientContext*)e->pInterface,
1021 pThis->m_pParameter->GetClipboard());
1022 }
1023#if FREERDP_VERSION_MAJOR >= 3
1024 else
1025 freerdp_client_OnChannelConnectedEventHandler(pContext, e);
1026#else
1027 else if (strcmp(e->name, RDPGFX_DVC_CHANNEL_NAME) == 0)
1028 {
1029 if (freerdp_settings_get_bool(pContext->settings, FreeRDP_SoftwareGdi)) {
1030 rdpGdi* gdi = pContext->gdi;
1031 // See: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpegfx/da5c75f9-cd99-450c-98c4-014a496942b0
1032 gdi_graphics_pipeline_init(gdi, (RdpgfxClientContext*) e->pInterface);
1033 }
1034 else
1035 qDebug(log, "Unimplemented: channel %s connected but libfreerdp is in HardwareGdi mode\n", e->name);
1036 }
1037 else if (strcmp(e->name, GEOMETRY_DVC_CHANNEL_NAME) == 0)
1038 {
1039 gdi_video_geometry_init(pContext->gdi, (GeometryClientContext*)e->pInterface);
1040 }
1041 else if (strcmp(e->name, VIDEO_DATA_DVC_CHANNEL_NAME) == 0)
1042 {
1043 gdi_video_data_init(pContext->gdi, (VideoClientContext*)e->pInterface);
1044 } else
1045 qDebug(log) << "Unimplemented: channel" << e->name << "connected but we can’t use it";
1046#endif
1047}
1048
1049void CBackendFreeRDP::OnChannelDisconnectedEventHandler(void *context,
1050 #if FREERDP_VERSION_MAJOR >= 3
1051 const
1052 #endif
1053 ChannelDisconnectedEventArgs *e)
1054{
1055 rdpContext* pContext = (rdpContext*)context;
1056 CBackendFreeRDP* pThis = ((ClientContext*)context)->pThis;
1057
1058 if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0) {
1059 qDebug(log) << "channel" << e->name << "disconnected";
1060 pThis->m_ClipBoard.UnInit((CliprdrClientContext*)e->pInterface,
1061 pThis->m_pParameter->GetClipboard());
1062 }
1063#if FREERDP_VERSION_MAJOR >= 3
1064 else
1065 freerdp_client_OnChannelDisconnectedEventHandler(pContext, e);
1066#else
1067 else if (strcmp(e->name, RDPGFX_DVC_CHANNEL_NAME) == 0)
1068 {
1069 if (freerdp_settings_get_bool(pContext->settings, FreeRDP_SoftwareGdi)) {
1070 rdpGdi* gdi = pContext->gdi;
1071 gdi_graphics_pipeline_uninit(gdi, (RdpgfxClientContext*) e->pInterface);
1072 }
1073 else
1074 qDebug(log, "Unimplemented: channel %s connected but libfreerdp is in HardwareGdi mode\n", e->name);
1075 }
1076 else
1077 qDebug(log) << "Unimplemented: channel" << e->name << "disconnected but we can’t use it";
1078#endif
1079
1080}
1081
1082UINT32 CBackendFreeRDP::GetImageFormat(QImage::Format format)
1083{
1084 switch (format) {
1085#if (QT_VERSION >= QT_VERSION_CHECK(5,2,0))
1086 case QImage::Format_RGBA8888:
1087 return PIXEL_FORMAT_RGBA32;
1088 case QImage::Format_RGBX8888:
1089 return PIXEL_FORMAT_RGBX32;
1090#endif
1091 case QImage::Format_RGB16:
1092 return PIXEL_FORMAT_RGB16;
1093 case QImage::Format_ARGB32:
1094 return PIXEL_FORMAT_BGRA32;
1095 case QImage::Format_RGB32:
1096 return PIXEL_FORMAT_BGRA32;
1097 default:
1098 break;
1099 }
1100 return 0;
1101}
1102
1103UINT32 CBackendFreeRDP::GetImageFormat()
1104{
1105 return GetImageFormat(m_Image.format());
1106}
1107
1108BOOL CBackendFreeRDP::CreateImage(rdpContext *context)
1109{
1110 Q_ASSERT(context);
1111 ClientContext* pContext = (ClientContext*)context;
1112 CBackendFreeRDP* pThis = pContext->pThis;
1113 rdpGdi* gdi = context->gdi;
1114 Q_ASSERT(pThis && gdi);
1115 pThis->m_Image = QImage(gdi->primary_buffer,
1116 static_cast<int>(gdi->width),
1117 static_cast<int>(gdi->height),
1118 QImage::Format_ARGB32);
1119 return TRUE;
1120}
1121
1122#if FREERDP_VERSION_MAJOR >= 3
1123#ifdef Q_OS_WINDOWS
1124static CREDUI_INFOW wfUiInfo = { sizeof(CREDUI_INFOW), NULL, L"Enter your credentials",
1125 L"Remote Desktop Security", NULL };
1126#endif
1127
1128BOOL CBackendFreeRDP::cb_authenticate_ex(freerdp* instance,
1129 char** username, char** password,
1130 char** domain, rdp_auth_reason reason)
1131{
1132 qDebug(log) << Q_FUNC_INFO << "reason:" << reason;
1133 if(!instance)
1134 return FALSE;
1135
1136 if(!username || !password || !domain) return FALSE;
1137
1138 rdpContext* pContext = (rdpContext*)instance->context;
1139#ifdef Q_OS_WINDOWS
1140 BOOL fSave;
1141 DWORD status;
1142 DWORD dwFlags;
1143 WCHAR UserNameW[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
1144 WCHAR UserW[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
1145 WCHAR DomainW[CREDUI_MAX_DOMAIN_TARGET_LENGTH + 1] = { 0 };
1146 WCHAR PasswordW[CREDUI_MAX_PASSWORD_LENGTH + 1] = { 0 };
1147
1148 WINPR_ASSERT(instance);
1149 WINPR_ASSERT(instance->context);
1150 WINPR_ASSERT(instance->context->settings);
1151
1152 WINPR_ASSERT(username);
1153 WINPR_ASSERT(domain);
1154 WINPR_ASSERT(password);
1155
1156 const WCHAR auth[] = L"Target credentials requested";
1157 const WCHAR authPin[] = L"PIN requested";
1158 const WCHAR gwAuth[] = L"Gateway credentials requested";
1159 const WCHAR* titleW = auth;
1160
1161 fSave = FALSE;
1162 dwFlags = CREDUI_FLAGS_DO_NOT_PERSIST | CREDUI_FLAGS_EXCLUDE_CERTIFICATES |
1163 CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS;
1164 switch (reason)
1165 {
1166 case AUTH_NLA:
1167 break;
1168 case AUTH_TLS:
1169 case AUTH_RDP:
1170 if ((*username) && (*password))
1171 return TRUE;
1172 break;
1173 case AUTH_SMARTCARD_PIN:
1174 dwFlags &= ~CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS;
1175 dwFlags |= CREDUI_FLAGS_PASSWORD_ONLY_OK | CREDUI_FLAGS_KEEP_USERNAME;
1176 titleW = authPin;
1177 if (*password)
1178 return TRUE;
1179 if (!(*username))
1180 *username = _strdup("PIN");
1181 break;
1182 case GW_AUTH_HTTP:
1183 case GW_AUTH_RDG:
1184 case GW_AUTH_RPC:
1185 titleW = gwAuth;
1186 break;
1187 default:
1188 return FALSE;
1189 }
1190
1191 if (*username)
1192 {
1193 ConvertUtf8ToWChar(*username, UserNameW, ARRAYSIZE(UserNameW));
1194 ConvertUtf8ToWChar(*username, UserW, ARRAYSIZE(UserW));
1195 }
1196
1197 if (*password)
1198 ConvertUtf8ToWChar(*password, PasswordW, ARRAYSIZE(PasswordW));
1199
1200 if (*domain)
1201 ConvertUtf8ToWChar(*domain, DomainW, ARRAYSIZE(DomainW));
1202
1203 if (_wcsnlen(PasswordW, ARRAYSIZE(PasswordW)) == 0)
1204 {
1205 status = CredUIPromptForCredentialsW(&wfUiInfo, titleW, NULL, 0, UserNameW,
1206 ARRAYSIZE(UserNameW), PasswordW,
1207 ARRAYSIZE(PasswordW), &fSave, dwFlags);
1208 if (status != NO_ERROR)
1209 {
1210 qCritical(log,
1211 "CredUIPromptForCredentials unexpected status: 0x%08lX",
1212 status);
1213 return FALSE;
1214 }
1215
1216 if ((dwFlags & CREDUI_FLAGS_KEEP_USERNAME) == 0)
1217 {
1218 status = CredUIParseUserNameW(UserNameW, UserW, ARRAYSIZE(UserW), DomainW,
1219 ARRAYSIZE(DomainW));
1220 if (status != NO_ERROR)
1221 {
1222 CHAR User[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
1223 CHAR UserName[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
1224 CHAR Domain[CREDUI_MAX_DOMAIN_TARGET_LENGTH + 1] = { 0 };
1225
1226 ConvertWCharNToUtf8(UserNameW, ARRAYSIZE(UserNameW), UserName, ARRAYSIZE(UserName));
1227 ConvertWCharNToUtf8(UserW, ARRAYSIZE(UserW), User, ARRAYSIZE(User));
1228 ConvertWCharNToUtf8(DomainW, ARRAYSIZE(DomainW), Domain, ARRAYSIZE(Domain));
1229 qCritical(log,
1230 "Failed to parse UserName: %s into User: %s Domain: %s",
1231 UserName, User, Domain);
1232 return FALSE;
1233 }
1234 }
1235 }
1236
1237 *username = ConvertWCharNToUtf8Alloc(UserW, ARRAYSIZE(UserW), NULL);
1238 if (!(*username))
1239 {
1240 qCritical(log) << "ConvertWCharNToUtf8Alloc failed" << status;
1241 return FALSE;
1242 }
1243
1244 if (_wcsnlen(DomainW, ARRAYSIZE(DomainW)) > 0)
1245 *domain = ConvertWCharNToUtf8Alloc(DomainW, ARRAYSIZE(DomainW), NULL);
1246 else
1247 *domain = _strdup("\0");
1248
1249 if (!(*domain))
1250 {
1251 free(*username);
1252 qCritical(log) << "strdup failed" << status;
1253 return FALSE;
1254 }
1255
1256 *password = ConvertWCharNToUtf8Alloc(PasswordW, ARRAYSIZE(PasswordW), NULL);
1257 if (!(*password))
1258 {
1259 free(*username);
1260 free(*domain);
1261 return FALSE;
1262 }
1263 return TRUE;
1264#else
1265 return cb_authenticate(instance, username, password, domain);
1266#endif //#ifdef Q_OS_WINDOWS
1267}
1268
1269//TODO: to be continue!!!
1270BOOL CBackendFreeRDP::cb_choose_smartcard(freerdp* instance,
1271 SmartcardCertInfo** cert_list,
1272 DWORD count,
1273 DWORD* choice, BOOL gateway)
1274{
1275 rdpContext* pContext = (rdpContext*)instance->context;
1276 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1277 QString msg("Multiple smartcards are available for use:\n");
1278 for (DWORD i = 0; i < count; i++)
1279 {
1280 const SmartcardCertInfo* cert = cert_list[i];
1281 char* reader = ConvertWCharToUtf8Alloc(cert->reader, NULL);
1282 char* container_name = ConvertWCharToUtf8Alloc(cert->containerName, NULL);
1283
1284 msg += QString::number(i) + " ";
1285 msg += QString(container_name) + "\n\t";
1286 msg += "Reader: " + QString(reader) + "\n\t";
1287 msg += "User: " + QString(cert->userHint) + + "@" + QString(cert->domainHint) + "\n\t";
1288 msg += "Subject: " + QString(cert->subject) + "\n\t";
1289 msg += "Issuer: " + QString(cert->issuer) + "\n\t";
1290 msg += "UPN: " + QString(cert->upn) + "\n";
1291
1292 free(reader);
1293 free(container_name);
1294 }
1295
1296 msg += "\nChoose a smartcard to use for ";
1297 if(gateway)
1298 msg += "gateway authentication";
1299 else
1300 msg += "logon";
1301
1302 msg += "(0 - " + QString::number(count - 1) + ")";
1303
1304 QString num;
1305 emit pThis->sigBlockInputDialog(tr("Choose"), tr("Please choose smartcard"),
1306 msg, num);
1307 if(!num.isEmpty())
1308 {
1309 bool ok = false;
1310 int n = num.toInt(&ok);
1311 if(ok)
1312 {
1313 *choice = n;
1314 return TRUE;
1315 }
1316 }
1317 return FALSE;
1318}
1319
1320#ifdef WITH_WINDOWS_CERT_STORE
1321/* https://stackoverflow.com/questions/1231178/load-an-pem-encoded-x-509-certificate-into-windows-cryptoapi/3803333#3803333
1322 */
1323/* https://github.com/microsoft/Windows-classic-samples/blob/main/Samples/Win7Samples/security/cryptoapi/peertrust/cpp/peertrust.cpp
1324 */
1325/* https://stackoverflow.com/questions/7340504/whats-the-correct-way-to-verify-an-ssl-certificate-in-win32
1326 */
1327
1328static void wf_report_error(char* wszMessage, DWORD dwErrCode)
1329{
1330 LPSTR pwszMsgBuf = NULL;
1331
1332 if (NULL != wszMessage && 0 != *wszMessage)
1333 {
1334 WLog_ERR(TAG, "%s", wszMessage);
1335 }
1336
1337 FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
1338 NULL, // Location of message
1339 // definition ignored
1340 dwErrCode, // Message identifier for
1341 // the requested message
1342 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Language identifier for
1343 // the requested message
1344 (LPSTR)&pwszMsgBuf, // Buffer that receives
1345 // the formatted message
1346 0, // Size of output buffer
1347 // not needed as allocate
1348 // buffer flag is set
1349 NULL // Array of insert values
1350 );
1351
1352 if (NULL != pwszMsgBuf)
1353 {
1354 WLog_ERR(TAG, "Error: 0x%08x (%d) %s", dwErrCode, dwErrCode, pwszMsgBuf);
1355 LocalFree(pwszMsgBuf);
1356 }
1357 else
1358 {
1359 WLog_ERR(TAG, "Error: 0x%08x (%d)", dwErrCode, dwErrCode);
1360 }
1361}
1362
1363static DWORD wf_is_x509_certificate_trusted(const char* common_name, const char* subject,
1364 const char* issuer, const char* fingerprint)
1365{
1366 HRESULT hr = CRYPT_E_NOT_FOUND;
1367
1368 DWORD dwChainFlags = CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
1369 PCCERT_CONTEXT pCert = NULL;
1370 HCERTCHAINENGINE hChainEngine = NULL;
1371 PCCERT_CHAIN_CONTEXT pChainContext = NULL;
1372
1373 CERT_ENHKEY_USAGE EnhkeyUsage = { 0 };
1374 CERT_USAGE_MATCH CertUsage = { 0 };
1375 CERT_CHAIN_PARA ChainPara = { 0 };
1376 CERT_CHAIN_POLICY_PARA ChainPolicy = { 0 };
1377 CERT_CHAIN_POLICY_STATUS PolicyStatus = { 0 };
1378 CERT_CHAIN_ENGINE_CONFIG EngineConfig = { 0 };
1379
1380 DWORD derPubKeyLen = WINPR_ASSERTING_INT_CAST(uint32_t, strlen(fingerprint));
1381 char* derPubKey = calloc(derPubKeyLen, sizeof(char));
1382 if (NULL == derPubKey)
1383 {
1384 WLog_ERR(TAG, "Could not allocate derPubKey");
1385 goto CleanUp;
1386 }
1387
1388 /*
1389 * Convert from PEM format to DER format - removes header and footer and decodes from base64
1390 */
1391 if (!CryptStringToBinaryA(fingerprint, 0, CRYPT_STRING_BASE64HEADER, derPubKey, &derPubKeyLen,
1392 NULL, NULL))
1393 {
1394 WLog_ERR(TAG, "CryptStringToBinary failed. Err: %d", GetLastError());
1395 goto CleanUp;
1396 }
1397
1398 //---------------------------------------------------------
1399 // Initialize data structures for chain building.
1400
1401 EnhkeyUsage.cUsageIdentifier = 0;
1402 EnhkeyUsage.rgpszUsageIdentifier = NULL;
1403
1404 CertUsage.dwType = USAGE_MATCH_TYPE_AND;
1405 CertUsage.Usage = EnhkeyUsage;
1406
1407 ChainPara.cbSize = sizeof(ChainPara);
1408 ChainPara.RequestedUsage = CertUsage;
1409
1410 ChainPolicy.cbSize = sizeof(ChainPolicy);
1411
1412 PolicyStatus.cbSize = sizeof(PolicyStatus);
1413
1414 EngineConfig.cbSize = sizeof(EngineConfig);
1415 EngineConfig.dwUrlRetrievalTimeout = 0;
1416
1417 pCert = CertCreateCertificateContext(X509_ASN_ENCODING, derPubKey, derPubKeyLen);
1418 if (NULL == pCert)
1419 {
1420 WLog_ERR(TAG, "FAILED: Certificate could not be parsed.");
1421 goto CleanUp;
1422 }
1423
1424 dwChainFlags |= CERT_CHAIN_ENABLE_PEER_TRUST;
1425
1426 // When this flag is set, end entity certificates in the
1427 // Trusted People store are trusted without doing any chain building
1428 // This optimizes the chain building process.
1429
1430 //---------------------------------------------------------
1431 // Create chain engine.
1432
1433 if (!CertCreateCertificateChainEngine(&EngineConfig, &hChainEngine))
1434 {
1435 hr = HRESULT_FROM_WIN32(GetLastError());
1436 goto CleanUp;
1437 }
1438
1439 //-------------------------------------------------------------------
1440 // Build a chain using CertGetCertificateChain
1441
1442 if (!CertGetCertificateChain(hChainEngine, // use the default chain engine
1443 pCert, // pointer to the end certificate
1444 NULL, // use the default time
1445 NULL, // search no additional stores
1446 &ChainPara, // use AND logic and enhanced key usage
1447 // as indicated in the ChainPara
1448 // data structure
1449 dwChainFlags,
1450 NULL, // currently reserved
1451 &pChainContext)) // return a pointer to the chain created
1452 {
1453 hr = HRESULT_FROM_WIN32(GetLastError());
1454 goto CleanUp;
1455 }
1456
1457 //---------------------------------------------------------------
1458 // Verify that the chain complies with policy
1459
1460 if (!CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_BASE, // use the base policy
1461 pChainContext, // pointer to the chain
1462 &ChainPolicy,
1463 &PolicyStatus)) // return a pointer to the policy status
1464 {
1465 hr = HRESULT_FROM_WIN32(GetLastError());
1466 goto CleanUp;
1467 }
1468
1469 if (PolicyStatus.dwError != S_OK)
1470 {
1471 wf_report_error("CertVerifyCertificateChainPolicy: Chain Status", PolicyStatus.dwError);
1472 hr = PolicyStatus.dwError;
1473 // Instruction: If the PolicyStatus.dwError is CRYPT_E_NO_REVOCATION_CHECK or
1474 // CRYPT_E_REVOCATION_OFFLINE, it indicates errors in obtaining
1475 // revocation information. These can be ignored since the retrieval of
1476 // revocation information depends on network availability
1477
1478 if (PolicyStatus.dwError == CRYPT_E_NO_REVOCATION_CHECK ||
1479 PolicyStatus.dwError == CRYPT_E_REVOCATION_OFFLINE)
1480 {
1481 hr = S_OK;
1482 }
1483
1484 goto CleanUp;
1485 }
1486
1487 WLog_INFO(TAG, "CertVerifyCertificateChainPolicy succeeded for %s (%s) issued by %s",
1488 common_name, subject, issuer);
1489
1490 hr = S_OK;
1491CleanUp:
1492
1493 if (FAILED(hr))
1494 {
1495 WLog_INFO(TAG, "CertVerifyCertificateChainPolicy failed for %s (%s) issued by %s",
1496 common_name, subject, issuer);
1497 wf_report_error(NULL, hr);
1498 }
1499
1500 free(derPubKey);
1501
1502 if (NULL != pChainContext)
1503 {
1504 CertFreeCertificateChain(pChainContext);
1505 }
1506
1507 if (NULL != hChainEngine)
1508 {
1509 CertFreeCertificateChainEngine(hChainEngine);
1510 }
1511
1512 if (NULL != pCert)
1513 {
1514 CertFreeCertificateContext(pCert);
1515 }
1516
1517 return (DWORD)hr;
1518}
1519#endif
1520
1521#endif //#if FREERDP_VERSION_MAJOR >= 3
1522
1523BOOL CBackendFreeRDP::cb_authenticate(freerdp* instance, char** username,
1524 char** password, char** domain)
1525{
1526 qDebug(log) << Q_FUNC_INFO;
1527 if(!instance)
1528 return FALSE;
1529 rdpContext* pContext = (rdpContext*)instance->context;
1530 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1531 if(!username || !password || !domain) return FALSE;
1532 if(*username && *password ) return TRUE;
1533
1534 int nRet = QDialog::Rejected;
1535 emit pThis->sigBlockShowWidget("CDlgGetUserPasswordFreeRDP",
1536 nRet, pThis->m_pParameter);
1537 if(QDialog::Accepted == nRet)
1538 {
1539 QString szPassword = pThis->m_pParameter->m_Net.m_User.GetPassword();
1540 QString szName = pThis->m_pParameter->m_Net.m_User.GetUser();
1541 QString szDomain = pThis->m_pParameter->GetDomain();
1542 if(!szDomain.isEmpty() && domain)
1543 *domain = _strdup(szDomain.toStdString().c_str());
1544 if(!szName.isEmpty() && username)
1545 *username = _strdup(szName.toStdString().c_str());
1546 if(password)
1547 *password = _strdup(szPassword.toStdString().c_str());
1548 } else
1549 return FALSE;
1550
1551 return TRUE;
1552}
1553
1554BOOL CBackendFreeRDP::cb_GatewayAuthenticate(freerdp *instance,
1555 char **username, char **password, char **domain)
1556{
1557 qDebug(log) << Q_FUNC_INFO;
1558 if(!instance)
1559 return FALSE;
1560
1561 rdpContext* pContext = (rdpContext*)instance->context;
1562 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1563 if(!username || !password || !domain) return FALSE;
1564 if(*username && *password ) return TRUE;
1565
1566 int nRet = QDialog::Rejected;
1567 emit pThis->sigBlockShowWidget("CDlgGetUserPasswordFreeRDP", nRet, pThis->m_pParameter);
1568 if(QDialog::Accepted == nRet)
1569 {
1570 QString szPassword = pThis->m_pParameter->m_Net.m_User.GetPassword();
1571 QString szName = pThis->m_pParameter->m_Net.m_User.GetUser();
1572 QString szDomain = pThis->m_pParameter->GetDomain();
1573 if(!szDomain.isEmpty() && domain)
1574 *domain = _strdup(szDomain.toStdString().c_str());
1575 if(!szName.isEmpty() && username)
1576 *username = _strdup(szName.toStdString().c_str());
1577 if(password)
1578 *password = _strdup(szPassword.toStdString().c_str());
1579 } else
1580 return FALSE;
1581
1582 return TRUE;
1583}
1584
1585int CBackendFreeRDP::cb_verify_x509_certificate(freerdp* instance,
1586 const BYTE* data, size_t length,
1587 const char* hostname, UINT16 port, DWORD flags)
1588{
1589 qDebug(log) << Q_FUNC_INFO;
1590 rdpContext* pContext = (rdpContext*)instance->context;
1591 QSslCertificate cert(QByteArray((const char*)data, length));
1592#if FREERDP_VERSION_MAJOR >= 3
1593 /* Newer versions of FreeRDP allow exposing the whole PEM by setting
1594 * FreeRDP_CertificateCallbackPreferPEM to TRUE
1595 */
1596 if (flags & VERIFY_CERT_FLAG_FP_IS_PEM) {
1597 return cb_verify_certificate_ex(
1598 instance, hostname, port,
1599 cert.issuerDisplayName().toStdString().c_str(),
1600 cert.subjectDisplayName().toStdString().c_str(),
1601 cert.issuerDisplayName().toStdString().c_str(),
1602 (const char*)data,
1603 flags);
1604 } else
1605#endif
1606 return cb_verify_certificate_ex(
1607 instance, hostname, port,
1608 cert.issuerDisplayName().toStdString().c_str(),
1609 cert.subjectDisplayName().toStdString().c_str(),
1610 cert.issuerDisplayName().toStdString().c_str(),
1611 cert.serialNumber().toStdString().c_str(),
1612 flags);
1613}
1614
1615static QString pem_cert_fingerprint(const char* pem, DWORD flags)
1616{
1617 QString szFingerPrint;
1618#if FREERDP_VERSION_MAJOR >= 3
1619 /* Newer versions of FreeRDP allow exposing the whole PEM by setting
1620 * FreeRDP_CertificateCallbackPreferPEM to TRUE
1621 */
1622 if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
1623 {
1624 rdpCertificate* cert = freerdp_certificate_new_from_pem(pem);
1625 if (!cert)
1626 return NULL;
1627
1628 char* fp = freerdp_certificate_get_fingerprint(cert);
1629 char* start = freerdp_certificate_get_validity(cert, TRUE);
1630 char* end = freerdp_certificate_get_validity(cert, FALSE);
1631 freerdp_certificate_free(cert);
1632
1633 szFingerPrint = QObject::tr("Valid from: ") + QString(start) + "\n";
1634 szFingerPrint += QObject::tr("Valid to: ") + QString(end) + "\n";
1635 szFingerPrint += QObject::tr("Fingerprint: ") + QString(fp) + "\n";
1636
1637 free(fp);
1638 free(start);
1639 free(end);
1640 } else
1641#endif
1642 szFingerPrint = QObject::tr("Fingerprint: ") + QString(pem) + "\n";
1643 return szFingerPrint;
1644}
1645
1661DWORD CBackendFreeRDP::cb_verify_certificate_ex(freerdp *instance,
1662 const char *host, UINT16 port,
1663 const char *common_name, const char *subject,
1664 const char *issuer, const char *fingerprint, DWORD flags)
1665{
1666 qDebug(log) << Q_FUNC_INFO;
1667
1668 rdpContext* pContext = (rdpContext*)instance->context;
1669 Q_ASSERT(pContext);
1670 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1671 Q_ASSERT(pThis);
1672 if(common_name)
1673 {
1674 //pThis->m_pParameter->SetServerName(common_name);
1675 emit pThis->sigServerName(common_name);
1676 }
1677
1678 if(!pThis->m_pParameter->GetShowVerifyDiaglog()) {
1679 /* return 1 to accept and store a certificate, 2 to accept
1680 * a certificate only for this session, 0 otherwise */
1681 return 2;
1682 }
1683
1684#if FREERDP_VERSION_MAJOR >= 3
1685#if defined(Q_OS_WIN) && defined(WITH_WINDOWS_CERT_STORE)
1686 if (flags & VERIFY_CERT_FLAG_FP_IS_PEM && !(flags & VERIFY_CERT_FLAG_MISMATCH))
1687 {
1688 if (wf_is_x509_certificate_trusted(common_name, subject, issuer, fingerprint) == S_OK)
1689 {
1690 return 2;
1691 }
1692 }
1693#endif
1694#endif
1695
1696 QString szType = tr("RDP-Server");
1697 if (flags & VERIFY_CERT_FLAG_GATEWAY)
1698 szType = tr("RDP-Gateway");
1699 if (flags & VERIFY_CERT_FLAG_REDIRECT)
1700 szType = tr("RDP-Redirect");
1701
1702 QString title(tr("Verify certificate"));
1703 QString message;
1704
1705 message += szType + tr(": %1:%2").arg(host, QString::number(port)) + "\n";
1706 message += tr("Common name: ") + common_name + "\n";
1707 message += tr("Subject: ") + subject + "\n";
1708 message += tr("Issuer: ") + issuer + "\n";
1709 message += pem_cert_fingerprint(fingerprint, flags);
1710 message += "\n";
1711 if(VERIFY_CERT_FLAG_CHANGED & flags) {
1712 message += tr("The above X.509 certificate is changed.\n"
1713 "It is possible that the server has changed its certificate, "
1714 "or Maybe it was attacked."
1715 "Please look at the OpenSSL documentation on "
1716 "how to add a private CA to the store.");
1717 } else {
1718 message += tr("The above X.509 certificate could not be verified.\n"
1719 "Possibly because you do not have the CA certificate "
1720 "in your certificate store, or the certificate has expired.\n"
1721 "Please look at the OpenSSL documentation on "
1722 "how to add a private CA to the store.");
1723 }
1724 message += "\n";
1725 message += "\n";
1726 message += tr("Yes - trusted") + "\n";
1727 message += tr("Ignore - temporary trusted") + "\n";
1728 message += tr("No - no trusted") + "\n";
1729
1730 QMessageBox::StandardButton nRet = QMessageBox::StandardButton::No;
1731 QMessageBox::StandardButtons buttons = QMessageBox::Yes | QMessageBox::Ignore | QMessageBox::No;
1732 bool bCheckBox = false;
1733 emit pThis->sigBlockShowMessageBox(title, message, buttons, nRet, bCheckBox,
1734 tr("Don't show again"));
1735 pThis->m_pParameter->SetShowVerifyDiaglog(!bCheckBox);
1736 emit pThis->m_pParameter->sigChanged();
1737 /* return 1 to accept and store a certificate, 2 to accept
1738 * a certificate only for this session, 0 otherwise */
1739 switch(nRet)
1740 {
1741 case QMessageBox::StandardButton::Yes:
1742 return 1;
1743 case QMessageBox::StandardButton::Ignore:
1744 return 2;
1745 default:
1746 return 0;
1747 }
1748 return 2;
1749}
1750
1770DWORD CBackendFreeRDP::cb_verify_changed_certificate_ex(freerdp *instance,
1771 const char *host, UINT16 port,
1772 const char *common_name, const char *subject,
1773 const char *issuer, const char *fingerprint,
1774 const char *old_subject, const char *old_issuer,
1775 const char *old_fingerprint, DWORD flags)
1776{
1777 qDebug(log) << Q_FUNC_INFO;
1778 rdpContext* pContext = (rdpContext*)instance->context;
1779 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1780 if(common_name)
1781 emit pThis->sigServerName(common_name);
1782
1783 if(!pThis->m_pParameter->GetShowVerifyDiaglog()) {
1784 /* return 1 to accept and store a certificate, 2 to accept
1785 * a certificate only for this session, 0 otherwise */
1786 return 2;
1787 }
1788
1789 QString szType = tr("RDP-Server");
1790 if (flags & VERIFY_CERT_FLAG_GATEWAY)
1791 szType = tr("RDP-Gateway");
1792 if (flags & VERIFY_CERT_FLAG_REDIRECT)
1793 szType = tr("RDP-Redirect");
1794
1795 QString title(tr("Verify changed certificate"));
1796 QString message;
1797 message += szType + tr(": %1:%2").arg(host, QString::number(port)) + "\n";
1798 message += tr("New Certificate details:") + "\n";
1799 message += " " + tr("name: ") + common_name + "\n";
1800 message += " " + tr("subject: ") + subject + "\n";
1801 message += " " + tr("issuer: ") + issuer + "\n";
1802 message += " " + pem_cert_fingerprint(fingerprint, flags) + "\n";
1803 message += tr("Old Certificate details:") + "\n";
1804 message += " " + tr("subject: ") + old_subject + "\n";
1805 message += " " + tr("issuer: ") + old_issuer + "\n";
1806 message += " " + pem_cert_fingerprint(old_fingerprint, flags) + "\n";
1807 message += "\n";
1808 message += tr("The above X.509 certificate could not be verified, "
1809 "possibly because you do not have the CA certificate "
1810 "in your certificate store, or the certificate has expired. "
1811 "Please look at the OpenSSL documentation on "
1812 "how to add a private CA to the store.");
1813 message += "\n";
1814 message += "\n";
1815 message += tr("Yes - trusted") + "\n";
1816 message += tr("Ignore - temporary trusted") + "\n";
1817 message += tr("No - no trusted") + "\n";
1818
1819 bool bCheckBox = false;
1820 QMessageBox::StandardButton nRet = QMessageBox::StandardButton::No;
1821 QMessageBox::StandardButtons buttons = QMessageBox::Yes | QMessageBox::Ignore | QMessageBox::No;
1822 emit pThis->sigBlockShowMessageBox(title, message, buttons, nRet, bCheckBox,
1823 tr("Don't show again"));
1824 pThis->m_pParameter->SetShowVerifyDiaglog(!bCheckBox);
1825 emit pThis->m_pParameter->sigChanged();
1826
1827 /* return 1 to accept and store a certificate, 2 to accept
1828 * a certificate only for this session, 0 otherwise */
1829 switch(nRet)
1830 {
1831 case QMessageBox::StandardButton::Yes:
1832 return 1;
1833 case QMessageBox::StandardButton::Ignore:
1834 return 2;
1835 default:
1836 return 0;
1837 }
1838
1839 /* return 1 to accept and store a certificate, 2 to accept
1840 * a certificate only for this session, 0 otherwise */
1841 return 2;
1842}
1843
1844BOOL CBackendFreeRDP::cb_present_gateway_message(
1845 freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
1846 BOOL isConsentMandatory, size_t length, const WCHAR* message)
1847{
1848 qDebug(log) << Q_FUNC_INFO;
1849
1850 if (!isDisplayMandatory && !isConsentMandatory)
1851 return TRUE;
1852
1853 /* special handling for consent messages (show modal dialog) */
1854 if (type == GATEWAY_MESSAGE_CONSENT && isConsentMandatory)
1855 {
1856 QString msgType = (type == GATEWAY_MESSAGE_CONSENT)
1857 ? tr("Consent message") : tr("Service message");
1858 msgType += "\n";
1859#if FREERDP_VERSION_MAJOR >= 3
1860 char* pMsg = ConvertWCharToUtf8Alloc(message, NULL);
1861 if(pMsg) {
1862 msgType += pMsg;
1863 free(pMsg);
1864 }
1865#else
1866 msgType += QString::fromStdWString((wchar_t*)message);
1867#endif
1868 msgType += "\n";
1869 msgType += tr("I understand and agree to the terms of this policy (Y/N)");
1870
1871 rdpContext* pContext = (rdpContext*)instance->context;
1872 CBackendFreeRDP* pThis = ((ClientContext*)pContext)->pThis;
1873 QMessageBox::StandardButton nRet = QMessageBox::No;
1874 bool bCheckBox = false;
1875 emit pThis->sigBlockShowMessageBox(tr("Gateway message"), msgType,
1876 QMessageBox::Yes|QMessageBox::No,
1877 nRet, bCheckBox);
1878 switch (nRet) {
1879 case QMessageBox::Yes:
1880 return TRUE;
1881 break;
1882 default:
1883 return FALSE;
1884 }
1885 }
1886 else
1887 return client_cli_present_gateway_message(
1888 instance, type, isDisplayMandatory,
1889 isConsentMandatory, length, message);
1890
1891 return TRUE;
1892}
1893
1894BOOL CBackendFreeRDP::cb_begin_paint(rdpContext *context)
1895{
1896 HGDI_DC hdc;
1897
1898 if (!context || !context->gdi || !context->gdi->primary
1899 || !context->gdi->primary->hdc)
1900 return FALSE;
1901
1902 hdc = context->gdi->primary->hdc;
1903
1904 if (!hdc || !hdc->hwnd || !hdc->hwnd->invalid)
1905 return FALSE;
1906
1907 hdc->hwnd->invalid->null = TRUE;
1908 hdc->hwnd->ninvalid = 0;
1909 return TRUE;
1910}
1911
1912BOOL CBackendFreeRDP::UpdateBuffer(INT32 x, INT32 y, INT32 w, INT32 h)
1913{
1914 if(x > m_Image.width() || y > m_Image.height()) {
1915 qCritical(log) << "The width and height out of range."
1916 << "Image width:" << m_Image.width()
1917 << "Image height:" << m_Image.height()
1918 << "w:" << w << "h:" << h;
1919 return FALSE;
1920 }
1921
1922 QRect rect(x, y, w, h);
1923 QImage img = m_Image.copy(rect);
1924 //qDebug(log) << "Image:" << rect << img.rect() << img;
1925 emit sigUpdateRect(rect, img);
1926 return TRUE;
1927}
1928
1929BOOL CBackendFreeRDP::cb_end_paint(rdpContext *context)
1930{
1931 //qDebug(log) << Q_FUNC_INFO;
1932 ClientContext* pContext = (ClientContext*)context;
1933 CBackendFreeRDP* pThis = pContext->pThis;
1934 INT32 ninvalid;
1935 HGDI_RGN cinvalid;
1936 REGION16 invalidRegion;
1937 RECTANGLE_16 invalidRect;
1938 const RECTANGLE_16* extents;
1939 HGDI_DC hdc;
1940 int i = 0;
1941
1942 if (!context || !context->gdi || !context->gdi->primary
1943 || !context->gdi->primary->hdc)
1944 return FALSE;
1945
1946 hdc = context->gdi->primary->hdc;
1947
1948 if (!hdc || !hdc->hwnd || !hdc->hwnd->invalid)
1949 return FALSE;
1950
1951 rdpGdi* gdi = context->gdi;
1952 if (gdi->suppressOutput)
1953 return TRUE;
1954
1955 HGDI_WND hwnd = context->gdi->primary->hdc->hwnd;
1956 ninvalid = hwnd->ninvalid; //无效区数量
1957 cinvalid = hwnd->cinvalid; //无效区数组
1958 if (ninvalid < 1)
1959 return TRUE;
1960
1961 region16_init(&invalidRegion);
1962
1963 for (i = 0; i < ninvalid; i++)
1964 {
1965 if(cinvalid[i].null)
1966 {
1967 qWarning(log) << "is null region" << cinvalid[i].x << cinvalid[i].y
1968 << cinvalid[i].w << cinvalid[i].h;
1969 continue;
1970 }
1971 invalidRect.left = cinvalid[i].x;
1972 invalidRect.top = cinvalid[i].y;
1973 invalidRect.right = cinvalid[i].x + cinvalid[i].w;
1974 invalidRect.bottom = cinvalid[i].y + cinvalid[i].h;
1975 region16_union_rect(&invalidRegion, &invalidRegion, &invalidRect);
1976 }
1977
1978 if (!region16_is_empty(&invalidRegion))
1979 {
1980 extents = region16_extents(&invalidRegion);
1981 //qDebug(log) << extents->left << extents->top << extents->right << extents->bottom;
1982 pThis->UpdateBuffer(extents->left,
1983 extents->top,
1984 extents->right - extents->left,
1985 extents->bottom - extents->top);
1986 }
1987
1988 region16_uninit(&invalidRegion);
1989
1990 return TRUE;
1991}
1992
1993BOOL CBackendFreeRDP::cb_desktop_resize(rdpContext* context)
1994{
1995 qDebug(log) << Q_FUNC_INFO;
1996 ClientContext* pContext = (ClientContext*)context;
1997 CBackendFreeRDP* pThis = pContext->pThis;
1998 rdpSettings* settings;
1999 if (!context || !context->settings)
2000 return FALSE;
2001 settings = context->settings;
2002 int desktopWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
2003 int desktopHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
2004
2005 if(!gdi_resize(context->gdi, desktopWidth, desktopHeight))
2006 return FALSE;
2007 if(!pThis->CreateImage(context))
2008 return FALSE;
2009
2010 emit pThis->sigSetDesktopSize(desktopWidth, desktopHeight);
2011 pThis->UpdateBuffer(0, 0, desktopWidth, desktopHeight);
2012 return TRUE;
2013}
2014
2015BOOL CBackendFreeRDP::cb_play_bell_sound(rdpContext *context, const PLAY_SOUND_UPDATE *play_sound)
2016{
2017 qDebug(log) << Q_FUNC_INFO;
2018 ClientContext* pContext = (ClientContext*)context;
2019 CBackendFreeRDP* pThis = pContext->pThis;
2020 WINPR_UNUSED(play_sound);
2021 QApplication::beep();
2022 return TRUE;
2023
2024 QString szFile;
2025#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
2026 QSoundEffect effect;
2027 effect.setSource(QUrl::fromLocalFile(szFile));
2028// effect.setLoopCount(1);
2029// effect.setVolume(1);
2030 effect.play();
2031#else
2032 QSound::play(szFile);
2033#endif
2034 return TRUE;
2035}
2036
2037/* This function is called to update the keyboard indicator LED */
2038BOOL CBackendFreeRDP::cb_keyboard_set_indicators(rdpContext *context, UINT16 led_flags)
2039{
2040 qDebug(log) << Q_FUNC_INFO;
2041 ClientContext* pContext = (ClientContext*)context;
2042 CBackendFreeRDP* pThis = pContext->pThis;
2043
2044 int state = CFrmViewer::LED_STATE::Unknown;
2045
2046 if (led_flags & KBD_SYNC_NUM_LOCK)
2047 state |= CFrmViewer::LED_STATE::NumLock;
2048 if (led_flags & KBD_SYNC_CAPS_LOCK)
2049 state |= CFrmViewer::LED_STATE::CapsLock;
2050 if (led_flags & KBD_SYNC_SCROLL_LOCK)
2051 state |= CFrmViewer::LED_STATE::ScrollLock;
2052
2053 emit pThis->sigUpdateLedState(state);
2054
2055 return TRUE;
2056}
2057
2058/* This function is called to set the IME state */
2059BOOL CBackendFreeRDP::cb_keyboard_set_ime_status(
2060 rdpContext* context, UINT16 imeId, UINT32 imeState, UINT32 imeConvMode)
2061{
2062 if (!context)
2063 return FALSE;
2064
2065 qWarning(log,
2066 "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
2067 ", imeConvMode=%08" PRIx32 ") ignored",
2068 imeId, imeState, imeConvMode);
2069 return TRUE;
2070}
2071
2072int CBackendFreeRDP::WakeUp()
2073{
2074 //qDebug(log) << Q_FUNC_INFO;
2075 if(m_writeEvent)
2076 SetEvent(m_writeEvent);
2077 return 0;
2078}
2079
2080// https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/2c1ced34-340a-46cd-be6e-fc8cab7c3b17
2081bool CBackendFreeRDP::SendMouseEvent(UINT16 flags, QPoint pos, bool isExtended)
2082{
2083 if(m_pParameter && m_pParameter->GetOnlyView()) return true;
2084 if(!m_pContext) return false;
2085
2086#if FREERDP_VERSION_MAJOR >= 3
2087 if(isExtended)
2088 freerdp_client_send_extended_button_event(
2089 &m_pContext->Context, FALSE, flags, pos.x(), pos.y());
2090 else
2091 freerdp_client_send_button_event(
2092 &m_pContext->Context, FALSE, flags, pos.x(), pos.y());
2093#else
2094 if(!m_pContext->Context.input) return false;
2095 return freerdp_input_send_mouse_event(
2096 m_pContext->Context.input, flags, pos.x(), pos.y());
2097#endif
2098 return true;
2099}
2100
2101void CBackendFreeRDP::wheelEvent(QWheelEvent *event)
2102{
2103 qDebug(logMouse) << Q_FUNC_INFO << event;
2104 if(!m_pContext) return;
2105 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2106
2107 UINT16 flags = 0;
2108 QPointF pos;
2109#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
2110 pos = event->position();
2111#else
2112 pos = event->pos();
2113#endif
2114 QPoint p = event->angleDelta();
2115 if(p.y() > 0)
2116 {
2117 flags |= PTR_FLAGS_WHEEL | p.y();
2118 }
2119 if(p.y() < 0)
2120 {
2121 flags |= PTR_FLAGS_WHEEL | PTR_FLAGS_WHEEL_NEGATIVE | -p.y();
2122 }
2123
2124 if(p.x() < 0)
2125 {
2126 flags |= PTR_FLAGS_HWHEEL | PTR_FLAGS_WHEEL_NEGATIVE | -p.x();
2127 }
2128 if(p.x() > 0)
2129 {
2130 flags |= PTR_FLAGS_HWHEEL | p.x();
2131 }
2132#if FREERDP_VERSION_MAJOR >= 3
2133 freerdp_client_send_wheel_event(&m_pContext->Context, flags);
2134 /*
2135 freerdp_client_send_button_event(
2136 &m_pContext->Context, FALSE, flags, pos.x(), pos.y());//*/
2137#else
2138 freerdp_input_send_mouse_event(
2139 m_pContext->Context.input, flags, pos.x(), pos.y());
2140#endif
2141}
2142
2143// https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/2c1ced34-340a-46cd-be6e-fc8cab7c3b17
2144void CBackendFreeRDP::mouseMoveEvent(QMouseEvent *event)
2145{
2146 qDebug(logMouse) << Q_FUNC_INFO << event << event->buttons() << event->button();
2147 if(!m_pContext) return;
2148 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2149 UINT16 flags = PTR_FLAGS_MOVE;
2150 SendMouseEvent(flags, event->pos(), false);
2151}
2152
2153void CBackendFreeRDP::mousePressEvent(QMouseEvent *event)
2154{
2155 qDebug(logMouse) << Q_FUNC_INFO << event << event->buttons() << event->button();
2156 if(!m_pContext) return;
2157 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2158
2159 UINT16 flags = 0;
2160 bool isExtended = false;
2161 Qt::MouseButton button = event->button();
2162 if (button & Qt::MouseButton::LeftButton)
2163 {
2164 flags = PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON1;
2165 }
2166 else if (button & Qt::MouseButton::RightButton)
2167 {
2168 flags = PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON2;
2169 }
2170 else if (button & Qt::MouseButton::MiddleButton)
2171 {
2172 flags = PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON3;
2173 }
2174 else if (button & Qt::MouseButton::ForwardButton)
2175 {
2176 flags = PTR_XFLAGS_DOWN | PTR_XFLAGS_BUTTON2;
2177 isExtended = true;
2178 }
2179 else if (button & Qt::MouseButton::BackButton)
2180 {
2181 flags = PTR_XFLAGS_DOWN | PTR_XFLAGS_BUTTON1;
2182 isExtended = true;
2183 }
2184 if (flags != 0)
2185 {
2186 SendMouseEvent(flags, event->pos(), isExtended);
2187 }
2188}
2189
2190void CBackendFreeRDP::mouseReleaseEvent(QMouseEvent *event)
2191{
2192 qDebug(logMouse) << Q_FUNC_INFO << event << event->buttons() << event->button();
2193 if(!m_pContext) return;
2194 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2195
2196 UINT16 flags = 0;
2197 bool isExtended = false;
2198 Qt::MouseButton button = event->button();
2199 if (button & Qt::MouseButton::LeftButton)
2200 {
2201 flags = PTR_FLAGS_BUTTON1;
2202 }
2203 else if (button & Qt::MouseButton::MiddleButton)
2204 {
2205 flags = PTR_FLAGS_BUTTON3;
2206 }
2207 else if (button & Qt::MouseButton::RightButton)
2208 {
2209 flags = PTR_FLAGS_BUTTON2;
2210 }
2211 else if (button & Qt::MouseButton::ForwardButton)
2212 {
2213 flags = PTR_XFLAGS_BUTTON2;
2214 isExtended = true;
2215 }
2216 else if (button & Qt::MouseButton::BackButton)
2217 {
2218 flags = PTR_XFLAGS_BUTTON1;
2219 isExtended = true;
2220 }
2221 if (flags != 0)
2222 {
2223 SendMouseEvent(flags, event->pos(), isExtended);
2224 }
2225}
2226
2227void CBackendFreeRDP::keyPressEvent(QKeyEvent *event)
2228{
2229 qDebug(logKey) << Q_FUNC_INFO << event;
2230 if(!m_pContext) return;
2231 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2232 // Convert to rdp scan code freerdp/scancode.h
2233 UINT32 k = CConvertKeyCode::QtToScanCode(event->key(), event->modifiers());
2234 if(RDP_SCANCODE_UNKNOWN != k)
2235#if FREERDP_VERSION_MAJOR >= 3
2236 freerdp_input_send_keyboard_event_ex(
2237 m_pContext->Context.context.input, true, true, k);
2238#else
2239 freerdp_input_send_keyboard_event_ex(
2240 m_pContext->Context.input, true, k);
2241#endif
2242}
2243
2244void CBackendFreeRDP::keyReleaseEvent(QKeyEvent *event)
2245{
2246 qDebug(logKey) << Q_FUNC_INFO << event;
2247 if(!m_pContext) return;
2248 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2249 UINT32 k = CConvertKeyCode::QtToScanCode(event->key(), event->modifiers());
2250 if(RDP_SCANCODE_UNKNOWN != k)
2251#if FREERDP_VERSION_MAJOR >= 3
2252 freerdp_input_send_keyboard_event_ex(
2253 m_pContext->Context.context.input, false, false, k);
2254#else
2255 freerdp_input_send_keyboard_event_ex(
2256 m_pContext->Context.input, false, k);
2257#endif
2258}
2259
2260void CBackendFreeRDP::InputMethodEvent(QInputMethodEvent *event)
2261{
2262 qDebug(logKey) << Q_FUNC_INFO << event;
2263 if(!m_pContext) return;
2264 if(m_pParameter && m_pParameter->GetOnlyView()) return;
2265 QString szText = event->commitString();
2266 if(szText.isEmpty())
2267 return;
2268 for(int i = 0; i < szText.length(); i++) {
2269 QChar c = szText.at(i);
2270#if FREERDP_VERSION_MAJOR >= 3
2271 freerdp_input_send_unicode_keyboard_event(m_pContext->Context.context.input, 0, (UINT16)c.unicode());
2272#else
2273 freerdp_input_send_unicode_keyboard_event(m_pContext->Context.input, 0, (UINT16)c.unicode());
2274#endif
2275 }
2276}
2277
2278int CBackendFreeRDP::RedirectionSound()
2279{
2280 rdpContext* pRdpContext = (rdpContext*)m_pContext;
2281 freerdp* instance = freerdp_client_get_instance(pRdpContext);
2282 rdpSettings* settings = instance->context->settings;
2283 Q_ASSERT(settings);
2284
2285 if(m_pParameter->GetRedirectionSound()
2286 == CParameterFreeRDP::RedirecionSoundType::Disable)
2287 {
2288 /* Disable sound */
2289 freerdp_settings_set_bool(settings, FreeRDP_AudioPlayback, FALSE);
2290 freerdp_settings_set_bool(settings, FreeRDP_RemoteConsoleAudio, FALSE);
2291 return 0;
2292 } else if(m_pParameter->GetRedirectionSound()
2293 == CParameterFreeRDP::RedirecionSoundType::Local)
2294 {
2295 freerdp_settings_set_bool(settings, FreeRDP_AudioPlayback, TRUE);
2296 freerdp_settings_set_bool(settings, FreeRDP_AudioCapture, TRUE);
2297 } else if(m_pParameter->GetRedirectionSound()
2298 == CParameterFreeRDP::RedirecionSoundType::Remote)
2299 {
2300 freerdp_settings_set_bool(settings, FreeRDP_RemoteConsoleAudio, TRUE);
2301 return 0;
2302 }
2303
2304 // Sound:
2305 // rdpsnd channel parameters format see: rdpsnd_process_addin_args in FreeRDP/channels/rdpsnd/client/rdpsnd_main.c
2306 // rdpsnd devices see: rdpsnd_process_connect in FreeRDP/channels/rdpsnd/client/rdpsnd_main.c
2307 // Format ag: /rdpsnd:sys:oss,dev:1,format:1
2308 //
2309 size_t count = 0;
2310 union
2311 {
2312 char** p;
2313 const char** pc;
2314 } ptr;
2315 ptr.p = CommandLineParseCommaSeparatedValuesEx("rdpsnd",
2316 m_pParameter->GetRedirectionSoundParameters().toStdString().c_str(),
2317 &count);
2318 BOOL status = freerdp_client_add_static_channel(settings, count,
2319 #if FREERDP_VERSION_MAJOR < 3
2320 ptr.p
2321 #else
2322 ptr.pc
2323 #endif
2324 );
2325 if (status)
2326 {
2327 status = freerdp_client_add_dynamic_channel(settings, count,
2328 #if FREERDP_VERSION_MAJOR < 3
2329 ptr.p
2330 #else
2331 ptr.pc
2332 #endif
2333 );
2334 }
2335
2336 if(!status)
2337 {
2338 qCritical(log) << "Load rdpsnd fail";
2339 return -1;
2340 }
2341
2342 return 0;
2343}
2344
2345int CBackendFreeRDP::RedirectionMicrophone()
2346{
2347 if(m_pParameter->GetRedirectionSound()
2348 == CParameterFreeRDP::RedirecionSoundType::Remote)
2349 return 0;
2350 if(!m_pParameter->GetRedirectionMicrophone())
2351 return 0;
2352
2353 rdpContext* pRdpContext = (rdpContext*)m_pContext;
2354 freerdp* instance = freerdp_client_get_instance(pRdpContext);
2355
2356 rdpSettings* settings = instance->context->settings;
2357 Q_ASSERT(settings);
2358
2359 freerdp_settings_set_bool(settings, FreeRDP_AudioCapture, TRUE);
2360
2361 // Microphone:
2362 // Audin channel parameters format see: audin_process_addin_args in FreeRDP/channels/audin/client/audin_main.c
2363 // Audin channel devices see: audin_DVCPluginEntry in FreeRDP/channels/audin/client/audin_main.c
2364 size_t count = 0;
2365 union
2366 {
2367 char** p;
2368 const char** pc;
2369 } ptr;
2370 ptr.p = CommandLineParseCommaSeparatedValuesEx("audin",
2371 m_pParameter->GetRedirectionMicrophoneParameters().toStdString().c_str(),
2372 &count);
2373 BOOL status = freerdp_client_add_dynamic_channel(settings, count,
2374 #if FREERDP_VERSION_MAJOR < 3
2375 ptr.p
2376 #else
2377 ptr.pc
2378 #endif
2379 );
2380
2381 if(!status)
2382 {
2383 qCritical(log) << "Load audin fail";
2384 return -1;
2385 }
2386
2387 return 0;
2388}
2389
2390int CBackendFreeRDP::RedirectionDriver()
2391{
2392 QStringList lstDrives = m_pParameter->GetRedirectionDrives();
2393 if(lstDrives.isEmpty())
2394 return 0;
2395
2396 rdpContext* pRdpContext = (rdpContext*)m_pContext;
2397 freerdp* instance = freerdp_client_get_instance(pRdpContext);
2398 rdpSettings* settings = instance->context->settings;
2399 Q_ASSERT(settings);
2400
2401 foreach (auto drive, lstDrives) {
2402 // Format: /drive:name,path
2403 char* pDrive = _strdup(drive.toStdString().c_str());
2404 const char* argvDrive[] = {"drive", pDrive};
2405 int count = sizeof(argvDrive) / sizeof(const char*);
2406 BOOL status = freerdp_client_add_device_channel(settings, count,
2407 #if FREERDP_VERSION_MAJOR < 3
2408 (char**)
2409 #endif
2410 argvDrive);
2411 if(pDrive) free(pDrive);
2412 if(!status)
2413 {
2414 qCritical(log) << "Load drive fail";
2415 return -1;
2416 }
2417 }
2418
2419 return 0;
2420}
2421
2422int CBackendFreeRDP::RedirectionPrinter()
2423{
2424 if(!m_pParameter->GetRedirectionPrinter())
2425 return 0;
2426
2427 rdpContext* pRdpContext = (rdpContext*)m_pContext;
2428 freerdp* instance = freerdp_client_get_instance(pRdpContext);
2429 rdpSettings* settings = instance->context->settings;
2430 Q_ASSERT(settings);
2431 // 获取系统的打印机列表，并在combobox中显示
2432 QStringList printerList = QPrinterInfo::availablePrinterNames();
2433 if(printerList.isEmpty())
2434 {
2435 qCritical(log) << "The printer is empty";
2436 return -1;
2437 }
2438 qDebug(log) << printerList;
2439
2440 // Format: /printer:<device>,<driver>,[default]
2441 const char* argvPrinter[] = {"printer", nullptr, nullptr};
2442 int count = sizeof(argvPrinter) / sizeof(const char*);
2443 BOOL status = freerdp_client_add_device_channel(settings, count,
2444 #if FREERDP_VERSION_MAJOR < 3
2445 (char**)
2446 #endif
2447 argvPrinter);
2448 if(!status) {
2449 qCritical(log) << "Load printer fail";
2450 return -2;
2451 }
2452
2453 return 0;
2454}
2455
2456int CBackendFreeRDP::RedirectionSerial()
2457{
2458 //TODO: FreeRDP don't support
2459 return 0;
2460 rdpContext* pRdpContext = (rdpContext*)m_pContext;
2461 freerdp* instance = freerdp_client_get_instance(pRdpContext);
2462 rdpSettings* settings = instance->context->settings;
2463 Q_ASSERT(settings);
2464
2465 QList<QSerialPortInfo> lstSerial = QSerialPortInfo::availablePorts();
2466
2467 int nNum = 1;
2468 foreach (auto serial, lstSerial) {
2469 // Format: /serial:<name>,<device>,[SerCx2|SerCx|Serial],[permissive]
2470 // ag: /serial:COM1,/dev/ttyS0
2471 qDebug(log) << "systemLocation:" << serial.systemLocation()
2472 << "portName:" << serial.portName()
2473 << "serialNumber:" << serial.serialNumber();
2474 char* pSerial = _strdup(serial.systemLocation().toStdString().c_str());
2475 char* pName = _strdup(serial.portName().toStdString().c_str());
2476 const char* argvSerial[] = {"serial", pName, pSerial};
2477 int count = sizeof(argvSerial) / sizeof(const char*);
2478 BOOL status = freerdp_client_add_device_channel(settings, count,
2479 #if FREERDP_VERSION_MAJOR < 3
2480 (char**)
2481 #endif
2482 argvSerial);
2483 if(pSerial) free(pSerial);
2484 if(pName) free(pName);
2485
2486 if(!status)
2487 {
2488 qCritical(log) << "Load drive fail";
2489 return -1;
2490 }
2491 }
2492
2493 return 0;
2494}
2495
2496void CBackendFreeRDP::slotConnectProxyServer(QString szHost, quint16 nPort)
2497{
2498 qDebug(log) << "Connect proxy server:" << szHost + ":" + QString::number(nPort);
2499 rdpContext* pContext = (rdpContext*)m_pContext;
2500 rdpSettings* settings = pContext->settings;
2501 if(!settings) {
2502 qCritical(log) << "settings is null";
2503 }
2504
2505 freerdp_settings_set_string(
2506 settings, FreeRDP_ServerHostname,
2507 szHost.toStdString().c_str());
2508 freerdp_settings_set_uint32(
2509 settings, FreeRDP_ServerPort,
2510 nPort);
2511
2512 int nRet = freerdp_client_start(pContext);
2513 if(nRet)
2514 {
2515 qCritical(log) << "freerdp_client_start fail";
2516 }
2517 qDebug(log) << "Connect proxy server:" << szHost + ":" + QString::number(nPort) << "end";
2518}
2519
2520#if HAVE_LIBSSH
2521CBackendFreeRDP::OnInitReturnValue CBackendFreeRDP::InitSSHTunnelPipe()
2522{
2523 // Start ssh thread
2524 if(!m_pThreadSSH)
2525 m_pThreadSSH = new CSSHTunnelThread(
2526 &m_pParameter->m_Proxy.m_SSH, &m_pParameter->m_Net, this);
2527 if(!m_pThreadSSH)
2528 return OnInitReturnValue::Fail;
2529 bool check = connect(m_pThreadSSH, SIGNAL(sigServer(QString, quint16)),
2530 this, SLOT(slotConnectProxyServer(QString, quint16)));
2531 Q_ASSERT(check);
2532 check = connect(m_pThreadSSH, SIGNAL(sigError(int,QString)),
2533 this, SIGNAL(sigError(int,QString)));
2534 Q_ASSERT(check);
2535 check = connect(m_pThreadSSH, SIGNAL(sigStop()),
2536 this, SIGNAL(sigStop()));
2537 Q_ASSERT(check);
2538 m_pThreadSSH->start();
2539 return OnInitReturnValue::UseOnProcess;
2540}
2541
2542int CBackendFreeRDP::CleanSSHTunnelPipe()
2543{
2544 if(m_pThreadSSH)
2545 {
2546 m_pThreadSSH->Exit();
2547 m_pThreadSSH = nullptr;
2548 }
2549 return 0;
2550}
2551#endif // HAVE_LIBSSH
CBackendDesktop
Remote desktop interface.
Definition BackendDesktop.h:38
CBackendDesktop::sigUpdateRect
void sigUpdateRect(const QRect &r, const QImage &image)
Notify the CFrmView update image.
CBackendFreeRDP::cb_verify_certificate_ex
static DWORD cb_verify_certificate_ex(freerdp *instance, const char *host, UINT16 port, const char *common_name, const char *subject, const char *issuer, const char *fingerprint, DWORD flags)
Callback set in the rdp_freerdp structure, and used to make a certificate validation when the connect...
Definition BackendFreeRDP.cpp:1661
CBackendFreeRDP::cb_pre_connect
static BOOL cb_pre_connect(freerdp *instance)
Callback given to freerdp_connect() to process the pre-connect operations.
Definition BackendFreeRDP.cpp:689
CBackendFreeRDP::cb_verify_x509_certificate
static int cb_verify_x509_certificate(freerdp *instance, const BYTE *data, size_t length, const char *hostname, UINT16 port, DWORD flags)
Callback used if user interaction is required to accept a certificate.
Definition BackendFreeRDP.cpp:1585
CBackendFreeRDP::OnInit
virtual OnInitReturnValue OnInit() override
Initialization.
Definition BackendFreeRDP.cpp:99
CBackendFreeRDP::cb_post_connect
static BOOL cb_post_connect(freerdp *instance)
Callback given to freerdp_connect() to perform post-connection operations.
Definition BackendFreeRDP.cpp:922
CBackendFreeRDP::OnClean
virtual int OnClean() override
Clean.
Definition BackendFreeRDP.cpp:315
CBackendFreeRDP::OnProcess
virtual int OnProcess() override
Specific operation processing of plug-in connection.
Definition BackendFreeRDP.cpp:365
CBackendFreeRDP::cb_verify_changed_certificate_ex
static DWORD cb_verify_changed_certificate_ex(freerdp *instance, const char *host, UINT16 port, const char *common_name, const char *subject, const char *issuer, const char *fingerprint, const char *old_subject, const char *old_issuer, const char *old_fingerprint, DWORD flags)
Callback set in the rdp_freerdp structure, and used to make a certificate validation when a stored ce...
Definition BackendFreeRDP.cpp:1770
CBackendFreeRDP::WakeUp
virtual int WakeUp() override
Wake up Backend thread(background thread)
Definition BackendFreeRDP.cpp:2072
CBackend::sigInformation
void sigInformation(const QString &szInfo)
Triggering from a background thread displays information in the main thread without blocking the back...
CBackend::sigStop
void sigStop()
Notify the user to stop.
CBackend::sigShowMessageBox
void sigShowMessageBox(const QString &szTitle, const QString &szMessage, const QMessageBox::Icon &icon=QMessageBox::Information)
Trigger the display of a message dialog (QMessageBox) in the main thread from a background thread wit...
CBackend::sigError
void sigError(const int nError, const QString &szError=QString())
Triggered when an error is generated.
CBackend::sigBlockShowMessageBox
void sigBlockShowMessageBox(const QString &szTitle, const QString &szMessage, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton &nRet, bool &checkBox, QString checkBoxContext=QString())
Block background threads and display message dialogs in foreground threads (QMessageBox)
CBackend::sigRunning
void sigRunning()
Emitted when the plugin is successfully started.
CBackend::sigBlockShowWidget
void sigBlockShowWidget(const QString &className, int &nRet, void *pContext)
Blocks the background thread and displays the window in the foreground thread.
CBackend::sigBlockInputDialog
void sigBlockInputDialog(const QString &szTitle, const QString &szLable, const QString &szMessage, QString &szText)
Block background threads and display input dialogs in foreground threads (QInputDialog)
CConvertKeyCode::QtToScanCode
static UINT32 QtToScanCode(int key, Qt::KeyboardModifiers modifiers)
CConvertKeyCode::QtToScanCode.
Definition ConvertKeyCode.cpp:17
CParameterFreeRDP
[Declare CParameterFreeRDP]
Definition ParameterFreeRDP.h:11
CParameterNet
Basic network parameters.
Definition ParameterNet.h:27
CParameterNet::m_User
CParameterUser m_User
[Instance user]
Definition ParameterNet.h:44
CParameter::sigChanged
void sigChanged()
emit when the parameter changes Usually if required, the corresponding parameter corresponds to a cha...
CSSHTunnelThread
Data is forwarded over a local socket and SSH tunnel.
Definition SSHTunnelThread.h:26
Author: Kang Lin (kl222@126.com)

Copyright (c) Kang Lin Studios All Rights Reserved