2013-03-19 04:12:51 +04:00
|
|
|
/**
|
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
|
|
* Windows Client
|
|
|
|
*
|
|
|
|
* Copyright 2009-2011 Jay Sorg
|
|
|
|
* Copyright 2010-2011 Vic Lee
|
|
|
|
* Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
2013-10-07 21:46:13 +04:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2013-03-19 04:12:51 +04:00
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <winpr/windows.h>
|
|
|
|
|
|
|
|
#include <winpr/crt.h>
|
|
|
|
#include <winpr/credui.h>
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <tchar.h>
|
2013-09-19 20:08:20 +04:00
|
|
|
#include <assert.h>
|
2013-03-19 04:12:51 +04:00
|
|
|
#include <sys/types.h>
|
|
|
|
|
2014-09-12 19:13:01 +04:00
|
|
|
#include <freerdp/log.h>
|
2014-10-24 18:30:54 +04:00
|
|
|
#include <freerdp/event.h>
|
2013-03-19 04:12:51 +04:00
|
|
|
#include <freerdp/freerdp.h>
|
|
|
|
#include <freerdp/constants.h>
|
|
|
|
|
2021-03-08 14:48:22 +03:00
|
|
|
#include <freerdp/locale/keyboard.h>
|
2014-10-25 03:46:02 +04:00
|
|
|
#include <freerdp/codec/region.h>
|
2013-03-19 04:12:51 +04:00
|
|
|
#include <freerdp/client/cmdline.h>
|
|
|
|
#include <freerdp/client/channels.h>
|
|
|
|
#include <freerdp/channels/channels.h>
|
|
|
|
|
|
|
|
#include "wf_gdi.h"
|
2014-10-25 03:46:02 +04:00
|
|
|
#include "wf_rail.h"
|
2014-09-13 00:30:57 +04:00
|
|
|
#include "wf_channels.h"
|
2013-03-19 04:12:51 +04:00
|
|
|
#include "wf_graphics.h"
|
|
|
|
#include "wf_cliprdr.h"
|
|
|
|
|
2014-09-13 00:30:57 +04:00
|
|
|
#include "wf_client.h"
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2013-03-19 19:11:14 +04:00
|
|
|
#include "resource.h"
|
|
|
|
|
2014-09-12 19:13:01 +04:00
|
|
|
#define TAG CLIENT_TAG("windows")
|
|
|
|
|
2019-08-29 16:17:59 +03:00
|
|
|
static BOOL wf_create_console(void)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2020-02-12 17:45:19 +03:00
|
|
|
#if defined(WITH_WIN_CONSOLE)
|
2019-08-29 14:47:53 +03:00
|
|
|
if (!AttachConsole(ATTACH_PARENT_PROCESS))
|
2019-08-29 16:17:59 +03:00
|
|
|
return FALSE;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
freopen("CONOUT$", "w", stdout);
|
2013-08-17 20:49:51 +04:00
|
|
|
freopen("CONOUT$", "w", stderr);
|
2020-02-12 17:45:19 +03:00
|
|
|
clearerr(stdout);
|
|
|
|
clearerr(stderr);
|
|
|
|
fflush(stdout);
|
|
|
|
fflush(stderr);
|
|
|
|
|
2019-08-29 20:28:50 +03:00
|
|
|
freopen("CONIN$", "r", stdin);
|
|
|
|
clearerr(stdin);
|
2019-08-29 16:17:59 +03:00
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
WLog_INFO(TAG, "Debug console created.");
|
2019-08-29 16:17:59 +03:00
|
|
|
|
|
|
|
return TRUE;
|
2020-02-12 17:45:19 +03:00
|
|
|
#else
|
|
|
|
return FALSE;
|
|
|
|
#endif
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-08-10 15:45:55 +03:00
|
|
|
static BOOL wf_end_paint(rdpContext* context)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
rdpGdi* gdi;
|
|
|
|
int ninvalid;
|
2014-10-25 03:46:02 +04:00
|
|
|
RECT updateRect;
|
2013-03-19 04:12:51 +04:00
|
|
|
HGDI_RGN cinvalid;
|
2014-10-25 03:46:02 +04:00
|
|
|
REGION16 invalidRegion;
|
|
|
|
RECTANGLE_16 invalidRect;
|
2016-08-03 13:09:24 +03:00
|
|
|
const RECTANGLE_16* extents;
|
|
|
|
wfContext* wfc = (wfContext*)context;
|
2014-10-25 03:46:02 +04:00
|
|
|
gdi = context->gdi;
|
2013-03-19 04:12:51 +04:00
|
|
|
ninvalid = gdi->primary->hdc->hwnd->ninvalid;
|
|
|
|
cinvalid = gdi->primary->hdc->hwnd->cinvalid;
|
|
|
|
|
2014-10-25 03:46:02 +04:00
|
|
|
if (ninvalid < 1)
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2014-10-25 03:46:02 +04:00
|
|
|
|
|
|
|
region16_init(&invalidRegion);
|
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
for (i = 0; i < ninvalid; i++)
|
|
|
|
{
|
2014-10-25 03:46:02 +04:00
|
|
|
invalidRect.left = cinvalid[i].x;
|
|
|
|
invalidRect.top = cinvalid[i].y;
|
|
|
|
invalidRect.right = cinvalid[i].x + cinvalid[i].w;
|
|
|
|
invalidRect.bottom = cinvalid[i].y + cinvalid[i].h;
|
|
|
|
region16_union_rect(&invalidRegion, &invalidRegion, &invalidRect);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!region16_is_empty(&invalidRegion))
|
|
|
|
{
|
|
|
|
extents = region16_extents(&invalidRegion);
|
|
|
|
updateRect.left = extents->left;
|
|
|
|
updateRect.top = extents->top;
|
|
|
|
updateRect.right = extents->right;
|
|
|
|
updateRect.bottom = extents->bottom;
|
|
|
|
InvalidateRect(wfc->hwnd, &updateRect, FALSE);
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2014-10-25 03:46:02 +04:00
|
|
|
if (wfc->rail)
|
|
|
|
wf_rail_invalidate_region(wfc, &invalidRegion);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2014-10-25 03:46:02 +04:00
|
|
|
|
|
|
|
region16_uninit(&invalidRegion);
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-08-10 14:12:54 +03:00
|
|
|
static BOOL wf_begin_paint(rdpContext* context)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2016-08-03 13:09:24 +03:00
|
|
|
HGDI_DC hdc;
|
2016-07-21 16:36:15 +03:00
|
|
|
|
2017-10-27 15:30:00 +03:00
|
|
|
if (!context || !context->gdi || !context->gdi->primary || !context->gdi->primary->hdc)
|
2016-08-03 13:09:24 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2017-10-27 15:30:00 +03:00
|
|
|
hdc = context->gdi->primary->hdc;
|
2016-07-21 16:36:15 +03:00
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
if (!hdc || !hdc->hwnd || !hdc->hwnd->invalid)
|
|
|
|
return FALSE;
|
|
|
|
|
2016-10-06 14:41:52 +03:00
|
|
|
hdc->hwnd->invalid->null = TRUE;
|
2016-08-03 13:09:24 +03:00
|
|
|
hdc->hwnd->ninvalid = 0;
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-08-10 14:33:34 +03:00
|
|
|
static BOOL wf_desktop_resize(rdpContext* context)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
BOOL same;
|
|
|
|
RECT rect;
|
|
|
|
rdpSettings* settings;
|
2016-08-03 13:09:24 +03:00
|
|
|
wfContext* wfc = (wfContext*)context;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
if (!context || !context->settings)
|
|
|
|
return FALSE;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
settings = context->settings;
|
2013-03-19 05:54:50 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->primary)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
same = (wfc->primary == wfc->drawing) ? TRUE : FALSE;
|
|
|
|
wf_image_free(wfc->primary);
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->primary = wf_image_new(wfc, settings->DesktopWidth, settings->DesktopHeight,
|
|
|
|
context->gdi->dstFormat, NULL);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2013-03-19 19:11:14 +04:00
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
if (!gdi_resize_ex(context->gdi, settings->DesktopWidth, settings->DesktopHeight, 0,
|
2016-08-10 14:33:34 +03:00
|
|
|
context->gdi->dstFormat, wfc->primary->pdata, NULL))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (same)
|
|
|
|
wfc->drawing = wfc->primary;
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->fullscreen != TRUE)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->hwnd)
|
2016-08-03 13:09:24 +03:00
|
|
|
SetWindowPos(wfc->hwnd, HWND_TOP, -1, -1, settings->DesktopWidth + wfc->diff.x,
|
2016-08-09 13:04:06 +03:00
|
|
|
settings->DesktopHeight + wfc->diff.y, SWP_NOMOVE);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wf_update_offset(wfc);
|
|
|
|
GetWindowRect(wfc->hwnd, &rect);
|
|
|
|
InvalidateRect(wfc->hwnd, &rect, TRUE);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2016-08-03 13:09:24 +03:00
|
|
|
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static BOOL wf_pre_connect(freerdp* instance)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2020-12-15 11:59:52 +03:00
|
|
|
UINT32 rc;
|
2013-06-16 06:57:21 +04:00
|
|
|
wfContext* wfc;
|
2021-03-08 14:48:22 +03:00
|
|
|
UINT32 desktopWidth;
|
|
|
|
UINT32 desktopHeight;
|
2013-06-16 06:57:21 +04:00
|
|
|
rdpContext* context;
|
2013-03-19 04:12:51 +04:00
|
|
|
rdpSettings* settings;
|
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
if (!instance || !instance->context || !instance->settings)
|
|
|
|
return FALSE;
|
2016-07-21 16:36:15 +03:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
context = instance->context;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)instance->context;
|
2013-03-19 04:12:51 +04:00
|
|
|
settings = instance->settings;
|
|
|
|
settings->OsMajorType = OSMAJORTYPE_WINDOWS;
|
|
|
|
settings->OsMinorType = OSMINORTYPE_WINDOWS_NT;
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->fullscreen = settings->Fullscreen;
|
2016-06-22 21:58:39 +03:00
|
|
|
wfc->fullscreen_toggle = settings->ToggleFullscreen;
|
2013-04-25 00:33:43 +04:00
|
|
|
desktopWidth = settings->DesktopWidth;
|
|
|
|
desktopHeight = settings->DesktopHeight;
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->percentscreen > 0)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
desktopWidth = (GetSystemMetrics(SM_CXSCREEN) * wfc->percentscreen) / 100;
|
2013-04-25 18:50:26 +04:00
|
|
|
settings->DesktopWidth = desktopWidth;
|
2013-06-16 06:57:21 +04:00
|
|
|
desktopHeight = (GetSystemMetrics(SM_CYSCREEN) * wfc->percentscreen) / 100;
|
2013-04-25 18:50:26 +04:00
|
|
|
settings->DesktopHeight = desktopHeight;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2014-03-04 11:35:21 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->fullscreen)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2013-04-25 18:50:26 +04:00
|
|
|
if (settings->UseMultimon)
|
|
|
|
{
|
2014-02-26 07:34:48 +04:00
|
|
|
desktopWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
|
|
|
|
desktopHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
|
2013-04-25 18:50:26 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-02-26 07:34:48 +04:00
|
|
|
desktopWidth = GetSystemMetrics(SM_CXSCREEN);
|
|
|
|
desktopHeight = GetSystemMetrics(SM_CYSCREEN);
|
2013-04-25 18:50:26 +04:00
|
|
|
}
|
2013-04-25 00:33:43 +04:00
|
|
|
}
|
|
|
|
|
2014-03-04 11:35:21 +04:00
|
|
|
/* FIXME: desktopWidth has a limitation that it should be divisible by 4,
|
|
|
|
* otherwise the screen will crash when connecting to an XP desktop.*/
|
|
|
|
desktopWidth = (desktopWidth + 3) & (~3);
|
|
|
|
|
2013-04-25 00:33:43 +04:00
|
|
|
if (desktopWidth != settings->DesktopWidth)
|
|
|
|
{
|
2021-03-08 14:48:22 +03:00
|
|
|
freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, desktopWidth);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2013-04-25 00:33:43 +04:00
|
|
|
if (desktopHeight != settings->DesktopHeight)
|
|
|
|
{
|
2021-03-08 14:48:22 +03:00
|
|
|
freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, desktopHeight);
|
2013-04-25 00:33:43 +04:00
|
|
|
}
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
if ((settings->DesktopWidth < 64) || (settings->DesktopHeight < 64) ||
|
2016-08-09 13:04:06 +03:00
|
|
|
(settings->DesktopWidth > 4096) || (settings->DesktopHeight > 4096))
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2016-12-14 00:47:08 +03:00
|
|
|
WLog_ERR(TAG, "invalid dimensions %lu %lu", settings->DesktopWidth,
|
2016-08-09 13:04:06 +03:00
|
|
|
settings->DesktopHeight);
|
2015-06-26 14:13:32 +03:00
|
|
|
return FALSE;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-08-10 15:45:55 +03:00
|
|
|
if (!freerdp_client_load_addins(context->channels, instance->settings))
|
|
|
|
return -1;
|
|
|
|
|
2020-12-15 11:59:52 +03:00
|
|
|
rc = freerdp_keyboard_init(freerdp_settings_get_uint32(settings, FreeRDP_KeyboardLayout));
|
2021-03-08 14:48:22 +03:00
|
|
|
freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, rc);
|
2019-11-06 17:24:51 +03:00
|
|
|
PubSub_SubscribeChannelConnected(instance->context->pubSub, wf_OnChannelConnectedEventHandler);
|
2014-09-13 00:30:57 +04:00
|
|
|
PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
|
2018-02-14 12:14:33 +03:00
|
|
|
wf_OnChannelDisconnectedEventHandler);
|
2013-03-19 04:12:51 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static void wf_add_system_menu(wfContext* wfc)
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2016-06-22 21:58:39 +03:00
|
|
|
HMENU hMenu;
|
2013-04-30 19:15:04 +04:00
|
|
|
MENUITEMINFO item_info;
|
2018-11-16 12:33:29 +03:00
|
|
|
|
2016-06-22 21:58:39 +03:00
|
|
|
if (wfc->fullscreen && !wfc->fullscreen_toggle)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2018-11-16 12:33:29 +03:00
|
|
|
|
2016-06-22 21:58:39 +03:00
|
|
|
hMenu = GetSystemMenu(wfc->hwnd, FALSE);
|
2013-04-30 19:15:04 +04:00
|
|
|
ZeroMemory(&item_info, sizeof(MENUITEMINFO));
|
2019-11-06 17:24:51 +03:00
|
|
|
item_info.fMask = MIIM_CHECKMARKS | MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_DATA;
|
2013-04-30 19:15:04 +04:00
|
|
|
item_info.cbSize = sizeof(MENUITEMINFO);
|
|
|
|
item_info.wID = SYSCOMMAND_ID_SMARTSIZING;
|
|
|
|
item_info.fType = MFT_STRING;
|
|
|
|
item_info.dwTypeData = _wcsdup(_T("Smart sizing"));
|
2019-11-06 17:24:51 +03:00
|
|
|
item_info.cch = (UINT)_wcslen(_T("Smart sizing"));
|
|
|
|
item_info.dwItemData = (ULONG_PTR)wfc;
|
2013-04-30 19:15:04 +04:00
|
|
|
InsertMenuItem(hMenu, 6, TRUE, &item_info);
|
|
|
|
|
2016-08-03 13:37:40 +03:00
|
|
|
if (wfc->context.settings->SmartSizing)
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
|
|
|
CheckMenuItem(hMenu, SYSCOMMAND_ID_SMARTSIZING, MF_CHECKED);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-21 11:54:09 +03:00
|
|
|
static WCHAR* wf_window_get_title(rdpSettings* settings)
|
|
|
|
{
|
|
|
|
BOOL port;
|
2018-12-10 16:31:38 +03:00
|
|
|
WCHAR* windowTitle = NULL;
|
2018-11-21 11:54:09 +03:00
|
|
|
size_t size;
|
2018-12-07 17:45:05 +03:00
|
|
|
char* name;
|
2018-11-21 11:54:09 +03:00
|
|
|
WCHAR prefix[] = L"FreeRDP:";
|
|
|
|
|
|
|
|
if (!settings)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
name = settings->ServerHostname;
|
|
|
|
|
|
|
|
if (settings->WindowTitle)
|
|
|
|
{
|
|
|
|
ConvertToUnicode(CP_UTF8, 0, settings->WindowTitle, -1, &windowTitle, 0);
|
|
|
|
return windowTitle;
|
|
|
|
}
|
|
|
|
|
|
|
|
port = (settings->ServerPort != 3389);
|
2020-07-06 10:16:55 +03:00
|
|
|
size = strlen(name) + 16 + wcslen(prefix);
|
2018-11-21 11:54:09 +03:00
|
|
|
windowTitle = calloc(size, sizeof(WCHAR));
|
|
|
|
|
|
|
|
if (!windowTitle)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!port)
|
2018-12-07 17:45:05 +03:00
|
|
|
_snwprintf_s(windowTitle, size, _TRUNCATE, L"%s %S", prefix, name);
|
2018-11-21 11:54:09 +03:00
|
|
|
else
|
2018-12-07 17:45:05 +03:00
|
|
|
_snwprintf_s(windowTitle, size, _TRUNCATE, L"%s %S:%u", prefix, name, settings->ServerPort);
|
2018-11-21 11:54:09 +03:00
|
|
|
|
|
|
|
return windowTitle;
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static BOOL wf_post_connect(freerdp* instance)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
2013-04-02 02:32:14 +04:00
|
|
|
DWORD dwStyle;
|
2013-03-19 04:12:51 +04:00
|
|
|
rdpCache* cache;
|
2013-06-16 06:57:21 +04:00
|
|
|
wfContext* wfc;
|
|
|
|
rdpContext* context;
|
2013-03-19 04:12:51 +04:00
|
|
|
rdpSettings* settings;
|
2013-10-07 21:46:13 +04:00
|
|
|
EmbedWindowEventArgs e;
|
2016-08-03 13:37:40 +03:00
|
|
|
const UINT32 format = PIXEL_FORMAT_BGRX32;
|
2013-03-19 04:12:51 +04:00
|
|
|
settings = instance->settings;
|
2013-06-16 06:57:21 +04:00
|
|
|
context = instance->context;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)instance->context;
|
2013-03-19 04:12:51 +04:00
|
|
|
cache = instance->context->cache;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->primary = wf_image_new(wfc, settings->DesktopWidth, settings->DesktopHeight, format, NULL);
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2016-08-10 14:33:34 +03:00
|
|
|
if (!gdi_init_ex(instance, format, 0, wfc->primary->pdata, NULL))
|
2016-08-03 13:09:24 +03:00
|
|
|
return FALSE;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
gdi = instance->context->gdi;
|
2014-09-11 17:51:44 +04:00
|
|
|
|
2016-08-03 13:09:24 +03:00
|
|
|
if (!settings->SoftwareGdi)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2016-08-03 13:09:24 +03:00
|
|
|
wf_gdi_register_update_callbacks(instance->update);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2018-11-21 11:54:09 +03:00
|
|
|
wfc->window_title = wf_window_get_title(settings);
|
|
|
|
|
|
|
|
if (!wfc->window_title)
|
|
|
|
return FALSE;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2013-10-07 21:46:13 +04:00
|
|
|
if (settings->EmbeddedWindow)
|
|
|
|
settings->Decorations = FALSE;
|
2015-03-17 15:02:41 +03:00
|
|
|
|
2014-08-20 00:59:22 +04:00
|
|
|
if (wfc->fullscreen)
|
|
|
|
dwStyle = WS_POPUP;
|
|
|
|
else if (!settings->Decorations)
|
2013-04-02 02:32:14 +04:00
|
|
|
dwStyle = WS_CHILD | WS_BORDER;
|
|
|
|
else
|
2019-11-06 17:24:51 +03:00
|
|
|
dwStyle =
|
|
|
|
WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX | WS_SIZEBOX | WS_MAXIMIZEBOX;
|
2013-04-02 02:32:14 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (!wfc->hwnd)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2021-03-08 14:48:22 +03:00
|
|
|
wfc->hwnd = CreateWindowEx(0, wfc->wndClassName, wfc->window_title, dwStyle, 0, 0, 0, 0,
|
|
|
|
wfc->hWndParent, NULL, wfc->hInstance, NULL);
|
2019-11-06 17:24:51 +03:00
|
|
|
SetWindowLongPtr(wfc->hwnd, GWLP_USERDATA, (LONG_PTR)wfc);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
wf_resize_window(wfc);
|
|
|
|
wf_add_system_menu(wfc);
|
2019-11-06 17:24:51 +03:00
|
|
|
BitBlt(wfc->primary->hdc, 0, 0, settings->DesktopWidth, settings->DesktopHeight, NULL, 0, 0,
|
|
|
|
BLACKNESS);
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->drawing = wfc->primary;
|
2013-10-07 21:46:13 +04:00
|
|
|
EventArgsInit(&e, "wfreerdp");
|
|
|
|
e.embed = FALSE;
|
2019-11-06 17:24:51 +03:00
|
|
|
e.handle = (void*)wfc->hwnd;
|
2015-03-17 15:02:41 +03:00
|
|
|
PubSub_OnEmbedWindow(context->pubSub, context, &e);
|
2013-06-16 06:57:21 +04:00
|
|
|
ShowWindow(wfc->hwnd, SW_SHOWNORMAL);
|
|
|
|
UpdateWindow(wfc->hwnd);
|
2016-08-10 14:33:34 +03:00
|
|
|
instance->update->BeginPaint = wf_begin_paint;
|
|
|
|
instance->update->DesktopResize = wf_desktop_resize;
|
2016-08-10 15:45:55 +03:00
|
|
|
instance->update->EndPaint = wf_end_paint;
|
2014-09-12 19:34:30 +04:00
|
|
|
wf_register_pointer(context->graphics);
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2014-09-12 19:34:30 +04:00
|
|
|
if (!settings->SoftwareGdi)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2016-08-03 13:09:24 +03:00
|
|
|
wf_register_graphics(context->graphics);
|
|
|
|
wf_gdi_register_update_callbacks(instance->update);
|
|
|
|
brush_cache_register_callbacks(instance->update);
|
|
|
|
glyph_cache_register_callbacks(instance->update);
|
|
|
|
bitmap_cache_register_callbacks(instance->update);
|
|
|
|
offscreen_cache_register_callbacks(instance->update);
|
|
|
|
palette_cache_register_callbacks(instance->update);
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2018-11-16 12:33:29 +03:00
|
|
|
wfc->floatbar = wf_floatbar_new(wfc, wfc->hInstance, settings->Floatbar);
|
2013-03-19 04:12:51 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2019-08-29 16:17:59 +03:00
|
|
|
static void wf_post_disconnect(freerdp* instance)
|
2016-08-10 14:33:34 +03:00
|
|
|
{
|
2018-11-21 11:54:09 +03:00
|
|
|
wfContext* wfc;
|
|
|
|
|
|
|
|
if (!instance || !instance->context || !instance->settings)
|
2019-08-29 16:17:59 +03:00
|
|
|
return;
|
2018-11-21 11:54:09 +03:00
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)instance->context;
|
2018-11-21 11:54:09 +03:00
|
|
|
free(wfc->window_title);
|
2016-08-10 14:33:34 +03:00
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
static CREDUI_INFOA wfUiInfo = { sizeof(CREDUI_INFOA), NULL, "Enter your credentials",
|
|
|
|
"Remote Desktop Security", NULL };
|
|
|
|
|
|
|
|
static BOOL wf_authenticate_raw(freerdp* instance, const char* title, char** username,
|
|
|
|
char** password, char** domain)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2019-08-29 20:28:50 +03:00
|
|
|
wfContext* wfc;
|
2013-03-19 04:12:51 +04:00
|
|
|
BOOL fSave;
|
|
|
|
DWORD status;
|
|
|
|
DWORD dwFlags;
|
2019-08-29 20:28:50 +03:00
|
|
|
char UserName[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
|
|
|
|
char Password[CREDUI_MAX_PASSWORD_LENGTH + 1] = { 0 };
|
|
|
|
char User[CREDUI_MAX_USERNAME_LENGTH + 1] = { 0 };
|
|
|
|
char Domain[CREDUI_MAX_DOMAIN_TARGET_LENGTH + 1] = { 0 };
|
|
|
|
|
|
|
|
if (!instance || !instance->context)
|
|
|
|
return FALSE;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)instance->context;
|
2019-08-29 20:28:50 +03:00
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
fSave = FALSE;
|
|
|
|
dwFlags = CREDUI_FLAGS_DO_NOT_PERSIST | CREDUI_FLAGS_EXCLUDE_CERTIFICATES;
|
2019-08-29 20:28:50 +03:00
|
|
|
|
2020-05-15 03:50:20 +03:00
|
|
|
if (username && *username)
|
|
|
|
strncpy(UserName, *username, CREDUI_MAX_USERNAME_LENGTH);
|
2019-08-29 20:28:50 +03:00
|
|
|
if (wfc->isConsole)
|
2019-11-06 17:24:51 +03:00
|
|
|
status = CredUICmdLinePromptForCredentialsA(
|
|
|
|
title, NULL, 0, UserName, CREDUI_MAX_USERNAME_LENGTH + 1, Password,
|
|
|
|
CREDUI_MAX_PASSWORD_LENGTH + 1, &fSave, dwFlags);
|
2019-08-29 20:28:50 +03:00
|
|
|
else
|
2019-11-06 17:24:51 +03:00
|
|
|
status = CredUIPromptForCredentialsA(&wfUiInfo, title, NULL, 0, UserName,
|
|
|
|
CREDUI_MAX_USERNAME_LENGTH + 1, Password,
|
|
|
|
CREDUI_MAX_PASSWORD_LENGTH + 1, &fSave, dwFlags);
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
if (status != NO_ERROR)
|
|
|
|
{
|
2016-12-14 00:47:08 +03:00
|
|
|
WLog_ERR(TAG, "CredUIPromptForCredentials unexpected status: 0x%08lX", status);
|
2013-03-19 04:12:51 +04:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
status = CredUIParseUserNameA(UserName, User, sizeof(User), Domain, sizeof(Domain));
|
|
|
|
// WLog_ERR(TAG, "User: %s Domain: %s Password: %s", User, Domain, Password);
|
2013-03-19 04:12:51 +04:00
|
|
|
*username = _strdup(User);
|
2016-08-03 13:09:24 +03:00
|
|
|
|
2015-06-17 23:08:02 +03:00
|
|
|
if (!(*username))
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "strdup failed", status);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
if (strlen(Domain) > 0)
|
|
|
|
*domain = _strdup(Domain);
|
2015-06-18 14:01:28 +03:00
|
|
|
else
|
|
|
|
*domain = _strdup("\0");
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2015-06-17 23:08:02 +03:00
|
|
|
if (!(*domain))
|
|
|
|
{
|
|
|
|
free(*username);
|
|
|
|
WLog_ERR(TAG, "strdup failed", status);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
*password = _strdup(Password);
|
2016-08-03 13:09:24 +03:00
|
|
|
|
2015-06-17 23:08:02 +03:00
|
|
|
if (!(*password))
|
|
|
|
{
|
|
|
|
free(*username);
|
|
|
|
free(*domain);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
static BOOL wf_authenticate(freerdp* instance, char** username, char** password, char** domain)
|
2015-06-23 15:59:54 +03:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
return wf_authenticate_raw(instance, instance->settings->ServerHostname, username, password,
|
|
|
|
domain);
|
2015-06-23 15:59:54 +03:00
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
static BOOL wf_gw_authenticate(freerdp* instance, char** username, char** password, char** domain)
|
2015-06-23 15:59:54 +03:00
|
|
|
{
|
|
|
|
char tmp[MAX_PATH];
|
2015-09-15 17:37:57 +03:00
|
|
|
sprintf_s(tmp, sizeof(tmp), "Gateway %s", instance->settings->GatewayHostname);
|
2015-06-23 15:59:54 +03:00
|
|
|
return wf_authenticate_raw(instance, tmp, username, password, domain);
|
|
|
|
}
|
|
|
|
|
2019-08-29 16:17:59 +03:00
|
|
|
static WCHAR* wf_format_text(const WCHAR* fmt, ...)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2019-08-29 16:17:59 +03:00
|
|
|
int rc;
|
|
|
|
size_t size = 1024;
|
|
|
|
WCHAR* buffer = calloc(size, sizeof(WCHAR));
|
|
|
|
if (!buffer)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
WCHAR* tmp;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
rc = vswprintf_s(buffer, size, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (rc <= 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
if ((size_t)rc < size)
|
|
|
|
return buffer;
|
|
|
|
|
|
|
|
size = (size_t)rc + 1;
|
|
|
|
tmp = realloc(buffer, size * sizeof(WCHAR));
|
|
|
|
if (!tmp)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
buffer = tmp;
|
2019-11-06 17:24:51 +03:00
|
|
|
} while (TRUE);
|
2019-08-29 16:17:59 +03:00
|
|
|
|
|
|
|
fail:
|
|
|
|
free(buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
static DWORD wf_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)
|
2019-08-29 16:17:59 +03:00
|
|
|
{
|
|
|
|
WCHAR* buffer;
|
|
|
|
WCHAR* caption;
|
|
|
|
int what = IDCANCEL;
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
buffer = wf_format_text(
|
|
|
|
L"Certificate details:\n"
|
|
|
|
L"\tCommonName: %S\n"
|
|
|
|
L"\tSubject: %S\n"
|
|
|
|
L"\tIssuer: %S\n"
|
|
|
|
L"\tThumbprint: %S\n"
|
|
|
|
L"\tHostMismatch: %S\n"
|
|
|
|
L"\n"
|
|
|
|
L"The above X.509 certificate could not be verified, possibly because you do not have "
|
|
|
|
L"the CA certificate in your certificate store, or the certificate has expired. "
|
|
|
|
L"Please look at the OpenSSL documentation on how to add a private CA to the store.\n"
|
|
|
|
L"\n"
|
|
|
|
L"YES\tAccept permanently\n"
|
|
|
|
L"NO\tAccept for this session only\n"
|
|
|
|
L"CANCEL\tAbort connection\n",
|
|
|
|
common_name, subject, issuer, fingerprint,
|
|
|
|
flags & VERIFY_CERT_FLAG_MISMATCH ? "Yes" : "No");
|
2019-08-29 16:17:59 +03:00
|
|
|
caption = wf_format_text(L"Verify certificate for %S:%hu", host, port);
|
|
|
|
|
2021-03-08 14:48:22 +03:00
|
|
|
WINPR_UNUSED(instance);
|
|
|
|
|
2019-08-29 16:17:59 +03:00
|
|
|
if (!buffer || !caption)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
what = MessageBoxW(NULL, buffer, caption, MB_YESNOCANCEL);
|
|
|
|
fail:
|
|
|
|
free(buffer);
|
|
|
|
free(caption);
|
|
|
|
|
2016-06-04 18:13:07 +03:00
|
|
|
/* return 1 to accept and store a certificate, 2 to accept
|
|
|
|
* a certificate only for this session, 0 otherwise */
|
2019-11-06 17:24:51 +03:00
|
|
|
switch (what)
|
2019-08-29 16:17:59 +03:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
case IDYES:
|
|
|
|
return 1;
|
|
|
|
case IDNO:
|
|
|
|
return 2;
|
|
|
|
default:
|
|
|
|
return 0;
|
2019-08-29 16:17:59 +03:00
|
|
|
}
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
static DWORD wf_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
|
|
|
|
const char* common_name, const char* subject,
|
|
|
|
const char* issuer, const char* new_fingerprint,
|
|
|
|
const char* old_subject, const char* old_issuer,
|
|
|
|
const char* old_fingerprint, DWORD flags)
|
2015-12-14 16:02:49 +03:00
|
|
|
{
|
2019-08-29 16:17:59 +03:00
|
|
|
WCHAR* buffer;
|
|
|
|
WCHAR* caption;
|
|
|
|
int what = IDCANCEL;
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
buffer = wf_format_text(
|
|
|
|
L"New Certificate details:\n"
|
|
|
|
L"\tCommonName: %S\n"
|
|
|
|
L"\tSubject: %S\n"
|
|
|
|
L"\tIssuer: %S\n"
|
|
|
|
L"\tThumbprint: %S\n"
|
|
|
|
L"\tHostMismatch: %S\n"
|
|
|
|
L"\n"
|
|
|
|
L"Old Certificate details:\n"
|
|
|
|
L"\tSubject: %S\n"
|
|
|
|
L"\tIssuer: %S\n"
|
|
|
|
L"\tThumbprint: %S"
|
|
|
|
L"The above X.509 certificate could not be verified, possibly because you do not have "
|
|
|
|
L"the CA certificate in your certificate store, or the certificate has expired. "
|
|
|
|
L"Please look at the OpenSSL documentation on how to add a private CA to the store.\n"
|
|
|
|
L"\n"
|
|
|
|
L"YES\tAccept permanently\n"
|
|
|
|
L"NO\tAccept for this session only\n"
|
|
|
|
L"CANCEL\tAbort connection\n",
|
|
|
|
common_name, subject, issuer, new_fingerprint,
|
|
|
|
flags & VERIFY_CERT_FLAG_MISMATCH ? "Yes" : "No", old_subject, old_issuer, old_fingerprint);
|
2019-08-29 16:17:59 +03:00
|
|
|
caption = wf_format_text(L"Verify certificate change for %S:%hu", host, port);
|
|
|
|
|
2021-03-08 14:48:22 +03:00
|
|
|
WINPR_UNUSED(instance);
|
2019-08-29 16:17:59 +03:00
|
|
|
if (!buffer || !caption)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
what = MessageBoxW(NULL, buffer, caption, MB_YESNOCANCEL);
|
|
|
|
fail:
|
|
|
|
free(buffer);
|
|
|
|
free(caption);
|
|
|
|
|
|
|
|
/* return 1 to accept and store a certificate, 2 to accept
|
|
|
|
* a certificate only for this session, 0 otherwise */
|
2019-11-06 17:24:51 +03:00
|
|
|
switch (what)
|
2019-08-29 16:17:59 +03:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
case IDYES:
|
|
|
|
return 1;
|
|
|
|
case IDNO:
|
|
|
|
return 2;
|
|
|
|
default:
|
|
|
|
return 0;
|
2019-08-29 16:17:59 +03:00
|
|
|
}
|
2015-12-14 16:02:49 +03:00
|
|
|
}
|
|
|
|
|
2020-08-03 13:06:08 +03:00
|
|
|
static BOOL wf_present_gateway_message(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
|
|
|
|
BOOL isConsentMandatory, size_t length, const WCHAR* message)
|
|
|
|
{
|
|
|
|
if (!isDisplayMandatory && !isConsentMandatory)
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
/* special handling for consent messages (show modal dialog) */
|
2020-08-04 10:11:41 +03:00
|
|
|
if (type == GATEWAY_MESSAGE_CONSENT && isConsentMandatory)
|
2020-08-03 13:06:08 +03:00
|
|
|
{
|
|
|
|
int mbRes;
|
|
|
|
WCHAR* msg;
|
|
|
|
|
|
|
|
msg = wf_format_text(L"%.*s\n\nI understand and agree to the terms of this policy", length,
|
|
|
|
message);
|
|
|
|
mbRes = MessageBoxW(NULL, msg, L"Consent Message", MB_YESNO);
|
|
|
|
free(msg);
|
|
|
|
|
|
|
|
if (mbRes != IDYES)
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return client_cli_present_gateway_message(instance, type, isDisplayMandatory,
|
|
|
|
isConsentMandatory, length, message);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2018-03-07 14:03:10 +03:00
|
|
|
static DWORD WINAPI wf_input_thread(LPVOID arg)
|
2014-05-21 10:52:57 +04:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
wMessage message;
|
|
|
|
wMessageQueue* queue;
|
2019-11-06 17:24:51 +03:00
|
|
|
freerdp* instance = (freerdp*)arg;
|
2016-08-03 13:09:24 +03:00
|
|
|
assert(NULL != instance);
|
2014-05-21 10:52:57 +04:00
|
|
|
status = 1;
|
2015-01-30 06:57:58 +03:00
|
|
|
queue = freerdp_get_message_queue(instance, FREERDP_INPUT_MESSAGE_QUEUE);
|
2014-05-21 10:52:57 +04:00
|
|
|
|
|
|
|
while (MessageQueue_Wait(queue))
|
|
|
|
{
|
|
|
|
while (MessageQueue_Peek(queue, &message, TRUE))
|
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
status = freerdp_message_queue_process_message(instance, FREERDP_INPUT_MESSAGE_QUEUE,
|
|
|
|
&message);
|
2014-05-21 10:52:57 +04:00
|
|
|
|
|
|
|
if (!status)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!status)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ExitThread(0);
|
2018-03-07 14:03:10 +03:00
|
|
|
return 0;
|
2014-05-21 10:52:57 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static DWORD WINAPI wf_client_thread(LPVOID lpParam)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
MSG msg;
|
2013-04-11 00:58:14 +04:00
|
|
|
int width;
|
|
|
|
int height;
|
2013-03-19 04:12:51 +04:00
|
|
|
BOOL msg_ret;
|
|
|
|
int quit_msg;
|
2015-01-30 06:57:58 +03:00
|
|
|
DWORD nCount;
|
2017-11-20 15:16:49 +03:00
|
|
|
DWORD error;
|
2015-01-30 06:57:58 +03:00
|
|
|
HANDLE handles[64];
|
2013-06-16 06:57:21 +04:00
|
|
|
wfContext* wfc;
|
2013-03-19 19:11:14 +04:00
|
|
|
freerdp* instance;
|
2015-01-30 06:57:58 +03:00
|
|
|
rdpContext* context;
|
2013-03-19 04:12:51 +04:00
|
|
|
rdpChannels* channels;
|
2014-05-21 10:52:57 +04:00
|
|
|
rdpSettings* settings;
|
|
|
|
BOOL async_input;
|
|
|
|
HANDLE input_thread;
|
2019-11-06 17:24:51 +03:00
|
|
|
instance = (freerdp*)lpParam;
|
2015-01-30 06:57:58 +03:00
|
|
|
context = instance->context;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)instance->context;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2015-01-30 06:57:58 +03:00
|
|
|
if (!freerdp_connect(instance))
|
2017-11-20 15:16:49 +03:00
|
|
|
goto end;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
channels = instance->context->channels;
|
2014-05-21 10:52:57 +04:00
|
|
|
settings = instance->context->settings;
|
|
|
|
async_input = settings->AsyncInput;
|
|
|
|
|
|
|
|
if (async_input)
|
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
if (!(input_thread = CreateThread(NULL, 0, wf_input_thread, instance, 0, NULL)))
|
2015-05-05 14:55:48 +03:00
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "Failed to create async input thread.");
|
|
|
|
goto disconnect;
|
|
|
|
}
|
2014-05-21 10:52:57 +04:00
|
|
|
}
|
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
while (1)
|
|
|
|
{
|
2015-01-30 06:57:58 +03:00
|
|
|
nCount = 0;
|
2013-03-19 04:12:51 +04:00
|
|
|
|
2014-10-03 18:27:47 +04:00
|
|
|
if (freerdp_focus_required(instance))
|
|
|
|
{
|
|
|
|
wf_event_focus_in(wfc);
|
|
|
|
wf_event_focus_in(wfc);
|
|
|
|
}
|
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2015-04-21 13:24:50 +03:00
|
|
|
DWORD tmp = freerdp_get_event_handles(context, &handles[nCount], 64 - nCount);
|
|
|
|
|
|
|
|
if (tmp == 0)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "freerdp_get_event_handles failed");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nCount += tmp;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2014-05-21 10:52:57 +04:00
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
if (MsgWaitForMultipleObjects(nCount, handles, FALSE, 1000, QS_ALLINPUT) == WAIT_FAILED)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
WLog_ERR(TAG, "wfreerdp_run: WaitForMultipleObjects failed: 0x%08lX", GetLastError());
|
2013-03-19 04:12:51 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2015-01-30 06:57:58 +03:00
|
|
|
if (!freerdp_check_event_handles(context))
|
2014-05-21 10:52:57 +04:00
|
|
|
{
|
2018-09-24 11:30:59 +03:00
|
|
|
if (client_auto_reconnect(instance))
|
2014-05-21 10:52:57 +04:00
|
|
|
continue;
|
2014-04-27 16:52:45 +04:00
|
|
|
|
2015-01-30 06:57:58 +03:00
|
|
|
WLog_ERR(TAG, "Failed to check FreeRDP file descriptor");
|
2014-05-21 10:52:57 +04:00
|
|
|
break;
|
|
|
|
}
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
2015-01-30 06:57:58 +03:00
|
|
|
|
2015-03-17 15:02:41 +03:00
|
|
|
if (freerdp_shall_disconnect(instance))
|
2013-03-19 04:12:51 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
quit_msg = FALSE;
|
2013-03-19 05:54:50 +04:00
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
|
|
|
|
{
|
|
|
|
msg_ret = GetMessage(&msg, NULL, 0, 0);
|
|
|
|
|
2013-04-11 00:58:14 +04:00
|
|
|
if (instance->settings->EmbeddedWindow)
|
|
|
|
{
|
|
|
|
if ((msg.message == WM_SETFOCUS) && (msg.lParam == 1))
|
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
PostMessage(wfc->hwnd, WM_SETFOCUS, 0, 0);
|
2013-04-11 00:58:14 +04:00
|
|
|
}
|
|
|
|
else if ((msg.message == WM_KILLFOCUS) && (msg.lParam == 1))
|
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
PostMessage(wfc->hwnd, WM_KILLFOCUS, 0, 0);
|
2013-04-11 00:58:14 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (msg.message == WM_SIZE)
|
|
|
|
{
|
|
|
|
width = LOWORD(msg.lParam);
|
|
|
|
height = HIWORD(msg.lParam);
|
2013-06-16 06:57:21 +04:00
|
|
|
SetWindowPos(wfc->hwnd, HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
|
2013-04-11 00:58:14 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((msg_ret == 0) || (msg_ret == -1))
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
quit_msg = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
TranslateMessage(&msg);
|
|
|
|
DispatchMessage(&msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (quit_msg)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup */
|
2014-05-21 10:52:57 +04:00
|
|
|
if (async_input)
|
|
|
|
{
|
|
|
|
wMessageQueue* input_queue;
|
2015-01-30 06:57:58 +03:00
|
|
|
input_queue = freerdp_get_message_queue(instance, FREERDP_INPUT_MESSAGE_QUEUE);
|
2016-08-03 13:09:24 +03:00
|
|
|
|
2015-05-23 23:47:18 +03:00
|
|
|
if (MessageQueue_PostQuit(input_queue, 0))
|
|
|
|
WaitForSingleObject(input_thread, INFINITE);
|
2014-05-21 10:52:57 +04:00
|
|
|
}
|
|
|
|
|
2015-05-05 14:55:48 +03:00
|
|
|
disconnect:
|
2013-06-16 06:57:21 +04:00
|
|
|
freerdp_disconnect(instance);
|
2016-08-09 17:48:02 +03:00
|
|
|
|
|
|
|
if (async_input)
|
|
|
|
CloseHandle(input_thread);
|
|
|
|
|
2017-11-20 15:16:49 +03:00
|
|
|
end:
|
|
|
|
error = freerdp_get_last_error(instance->context);
|
|
|
|
WLog_DBG(TAG, "Main thread exited with %" PRIu32, error);
|
|
|
|
ExitThread(error);
|
|
|
|
return error;
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static DWORD WINAPI wf_keyboard_thread(LPVOID lpParam)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
MSG msg;
|
|
|
|
BOOL status;
|
2013-06-16 06:57:21 +04:00
|
|
|
wfContext* wfc;
|
2013-03-19 04:12:51 +04:00
|
|
|
HHOOK hook_handle;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc = (wfContext*)lpParam;
|
2013-09-05 15:39:43 +04:00
|
|
|
assert(NULL != wfc);
|
2019-11-06 17:24:51 +03:00
|
|
|
hook_handle = SetWindowsHookEx(WH_KEYBOARD_LL, wf_ll_kbd_proc, wfc->hInstance, 0);
|
2013-03-19 04:12:51 +04:00
|
|
|
|
|
|
|
if (hook_handle)
|
|
|
|
{
|
2013-03-19 05:54:50 +04:00
|
|
|
while ((status = GetMessage(&msg, NULL, 0, 0)) != 0)
|
2013-03-19 04:12:51 +04:00
|
|
|
{
|
|
|
|
if (status == -1)
|
|
|
|
{
|
2015-01-30 06:57:58 +03:00
|
|
|
WLog_ERR(TAG, "keyboard thread error getting message");
|
2013-03-19 04:12:51 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TranslateMessage(&msg);
|
|
|
|
DispatchMessage(&msg);
|
|
|
|
}
|
|
|
|
}
|
2013-03-19 05:54:50 +04:00
|
|
|
|
2013-03-19 04:12:51 +04:00
|
|
|
UnhookWindowsHookEx(hook_handle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-30 06:57:58 +03:00
|
|
|
WLog_ERR(TAG, "failed to install keyboard hook");
|
2013-03-19 04:12:51 +04:00
|
|
|
}
|
|
|
|
|
2014-09-12 19:13:01 +04:00
|
|
|
WLog_DBG(TAG, "Keyboard thread exited.");
|
2013-09-05 15:39:43 +04:00
|
|
|
ExitThread(0);
|
2013-04-11 00:58:14 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-09 11:54:31 +03:00
|
|
|
int freerdp_client_set_window_size(wfContext* wfc, int width, int height)
|
2013-04-30 23:18:26 +04:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
WLog_DBG(TAG, "freerdp_client_set_window_size %d, %d", width, height);
|
2014-09-12 19:13:01 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if ((width != wfc->client_width) || (height != wfc->client_height))
|
2013-04-11 00:58:14 +04:00
|
|
|
{
|
2016-08-03 13:09:24 +03:00
|
|
|
PostThreadMessage(wfc->mainThreadId, WM_SIZE, SIZE_RESTORED,
|
2019-11-06 17:24:51 +03:00
|
|
|
((UINT)height << 16) | (UINT)width);
|
2013-04-11 00:58:14 +04:00
|
|
|
}
|
|
|
|
|
2013-03-19 05:54:50 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
void wf_size_scrollbars(wfContext* wfc, UINT32 client_width, UINT32 client_height)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2014-02-10 09:34:17 +04:00
|
|
|
if (wfc->disablewindowtracking)
|
2013-04-26 23:46:36 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
// prevent infinite message loop
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->disablewindowtracking = TRUE;
|
2013-04-26 23:46:36 +04:00
|
|
|
|
2016-08-03 13:37:40 +03:00
|
|
|
if (wfc->context.settings->SmartSizing)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->xCurrentScroll = 0;
|
|
|
|
wfc->yCurrentScroll = 0;
|
2013-04-30 19:15:04 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (wfc->xScrollVisible || wfc->yScrollVisible)
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
if (ShowScrollBar(wfc->hwnd, SB_BOTH, FALSE))
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->xScrollVisible = FALSE;
|
|
|
|
wfc->yScrollVisible = FALSE;
|
2013-04-30 19:15:04 +04:00
|
|
|
}
|
|
|
|
}
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SCROLLINFO si;
|
2013-06-16 06:57:21 +04:00
|
|
|
BOOL horiz = wfc->xScrollVisible;
|
2019-05-08 13:58:01 +03:00
|
|
|
BOOL vert = wfc->yScrollVisible;
|
2013-04-26 23:46:36 +04:00
|
|
|
|
2016-08-03 13:37:40 +03:00
|
|
|
if (!horiz && client_width < wfc->context.settings->DesktopWidth)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2015-03-17 15:02:41 +03:00
|
|
|
horiz = TRUE;
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
2019-11-06 17:24:51 +03:00
|
|
|
else if (horiz &&
|
|
|
|
client_width >=
|
|
|
|
wfc->context.settings->DesktopWidth /* - GetSystemMetrics(SM_CXVSCROLL)*/)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2015-03-17 15:02:41 +03:00
|
|
|
horiz = FALSE;
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
|
2016-08-03 13:37:40 +03:00
|
|
|
if (!vert && client_height < wfc->context.settings->DesktopHeight)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
|
|
|
vert = TRUE;
|
|
|
|
}
|
2019-11-06 17:24:51 +03:00
|
|
|
else if (vert &&
|
|
|
|
client_height >=
|
|
|
|
wfc->context.settings->DesktopHeight /* - GetSystemMetrics(SM_CYHSCROLL)*/)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
|
|
|
vert = FALSE;
|
|
|
|
}
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
if (horiz == vert && (horiz != wfc->xScrollVisible && vert != wfc->yScrollVisible))
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
if (ShowScrollBar(wfc->hwnd, SB_BOTH, horiz))
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->xScrollVisible = horiz;
|
|
|
|
wfc->yScrollVisible = vert;
|
2013-04-30 19:15:04 +04:00
|
|
|
}
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (horiz != wfc->xScrollVisible)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
if (ShowScrollBar(wfc->hwnd, SB_HORZ, horiz))
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->xScrollVisible = horiz;
|
2013-04-30 19:15:04 +04:00
|
|
|
}
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
if (vert != wfc->yScrollVisible)
|
2013-04-26 23:46:36 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
if (ShowScrollBar(wfc->hwnd, SB_VERT, vert))
|
2013-04-30 19:15:04 +04:00
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->yScrollVisible = vert;
|
2013-04-30 19:15:04 +04:00
|
|
|
}
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (horiz)
|
|
|
|
{
|
2015-03-17 15:02:41 +03:00
|
|
|
// The horizontal scrolling range is defined by
|
|
|
|
// (bitmap_width) - (client_width). The current horizontal
|
|
|
|
// scroll value remains within the horizontal scrolling range.
|
2016-08-03 13:37:40 +03:00
|
|
|
wfc->xMaxScroll = MAX(wfc->context.settings->DesktopWidth - client_width, 0);
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->xCurrentScroll = MIN(wfc->xCurrentScroll, wfc->xMaxScroll);
|
2015-03-17 15:02:41 +03:00
|
|
|
si.cbSize = sizeof(si);
|
2019-11-06 17:24:51 +03:00
|
|
|
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
|
|
|
|
si.nMin = wfc->xMinScroll;
|
|
|
|
si.nMax = wfc->context.settings->DesktopWidth;
|
|
|
|
si.nPage = client_width;
|
|
|
|
si.nPos = wfc->xCurrentScroll;
|
2013-06-16 06:57:21 +04:00
|
|
|
SetScrollInfo(wfc->hwnd, SB_HORZ, &si, TRUE);
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (vert)
|
|
|
|
{
|
2015-03-17 15:02:41 +03:00
|
|
|
// The vertical scrolling range is defined by
|
|
|
|
// (bitmap_height) - (client_height). The current vertical
|
|
|
|
// scroll value remains within the vertical scrolling range.
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->yMaxScroll = MAX(wfc->context.settings->DesktopHeight - client_height, 0);
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->yCurrentScroll = MIN(wfc->yCurrentScroll, wfc->yMaxScroll);
|
2015-03-17 15:02:41 +03:00
|
|
|
si.cbSize = sizeof(si);
|
2019-11-06 17:24:51 +03:00
|
|
|
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
|
|
|
|
si.nMin = wfc->yMinScroll;
|
|
|
|
si.nMax = wfc->context.settings->DesktopHeight;
|
|
|
|
si.nPage = client_height;
|
|
|
|
si.nPos = wfc->yCurrentScroll;
|
2013-06-16 06:57:21 +04:00
|
|
|
SetScrollInfo(wfc->hwnd, SB_VERT, &si, TRUE);
|
2013-04-26 23:46:36 +04:00
|
|
|
}
|
|
|
|
}
|
2013-04-30 19:15:04 +04:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->disablewindowtracking = FALSE;
|
|
|
|
wf_update_canvas_diff(wfc);
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static BOOL wfreerdp_client_global_init(void)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
|
|
|
WSADATA wsaData;
|
|
|
|
|
|
|
|
WSAStartup(0x101, &wsaData);
|
2019-08-29 14:47:53 +03:00
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0);
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2013-06-16 06:57:21 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static void wfreerdp_client_global_uninit(void)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
|
|
|
WSACleanup();
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static BOOL wfreerdp_client_new(freerdp* instance, rdpContext* context)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
2019-08-29 16:17:59 +03:00
|
|
|
wfContext* wfc = (wfContext*)context;
|
|
|
|
if (!wfc)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-08-29 20:28:50 +03:00
|
|
|
// AttachConsole and stdin do not work well.
|
|
|
|
// Use GUI input dialogs instead of command line ones.
|
2019-11-04 13:18:53 +03:00
|
|
|
wfc->isConsole = wf_create_console();
|
2019-08-29 16:17:59 +03:00
|
|
|
|
2015-04-28 18:00:41 +03:00
|
|
|
if (!(wfreerdp_client_global_init()))
|
|
|
|
return FALSE;
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
instance->PreConnect = wf_pre_connect;
|
|
|
|
instance->PostConnect = wf_post_connect;
|
2016-08-10 14:33:34 +03:00
|
|
|
instance->PostDisconnect = wf_post_disconnect;
|
2013-06-16 06:57:21 +04:00
|
|
|
instance->Authenticate = wf_authenticate;
|
2015-06-23 15:59:54 +03:00
|
|
|
instance->GatewayAuthenticate = wf_gw_authenticate;
|
2019-08-29 20:28:50 +03:00
|
|
|
if (wfc->isConsole)
|
|
|
|
{
|
|
|
|
instance->VerifyCertificateEx = client_cli_verify_certificate_ex;
|
|
|
|
instance->VerifyChangedCertificateEx = client_cli_verify_changed_certificate_ex;
|
2020-08-03 13:06:08 +03:00
|
|
|
instance->PresentGatewayMessage = client_cli_present_gateway_message;
|
2019-08-29 20:28:50 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
instance->VerifyCertificateEx = wf_verify_certificate_ex;
|
|
|
|
instance->VerifyChangedCertificateEx = wf_verify_changed_certificate_ex;
|
2020-08-03 13:06:08 +03:00
|
|
|
instance->PresentGatewayMessage = wf_present_gateway_message;
|
2019-08-29 20:28:50 +03:00
|
|
|
}
|
2019-08-29 16:17:59 +03:00
|
|
|
|
2015-04-28 18:00:41 +03:00
|
|
|
return TRUE;
|
2013-06-16 06:57:21 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static void wfreerdp_client_free(freerdp* instance, rdpContext* context)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
2021-03-08 14:48:22 +03:00
|
|
|
WINPR_UNUSED(instance);
|
2015-04-28 18:00:41 +03:00
|
|
|
if (!context)
|
|
|
|
return;
|
2013-06-16 06:57:21 +04:00
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static int wfreerdp_client_start(rdpContext* context)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
|
|
|
HWND hWndParent;
|
|
|
|
HINSTANCE hInstance;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfContext* wfc = (wfContext*)context;
|
2013-06-16 06:57:21 +04:00
|
|
|
freerdp* instance = context->instance;
|
|
|
|
hInstance = GetModuleHandle(NULL);
|
2019-11-06 17:24:51 +03:00
|
|
|
hWndParent = (HWND)instance->settings->ParentWindowId;
|
2013-06-16 06:57:21 +04:00
|
|
|
instance->settings->EmbeddedWindow = (hWndParent) ? TRUE : FALSE;
|
|
|
|
wfc->hWndParent = hWndParent;
|
|
|
|
wfc->hInstance = hInstance;
|
|
|
|
wfc->cursor = LoadCursor(NULL, IDC_ARROW);
|
|
|
|
wfc->icon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
|
|
|
|
wfc->wndClassName = _tcsdup(_T("FreeRDP"));
|
|
|
|
wfc->wndClass.cbSize = sizeof(WNDCLASSEX);
|
|
|
|
wfc->wndClass.style = CS_HREDRAW | CS_VREDRAW;
|
|
|
|
wfc->wndClass.lpfnWndProc = wf_event_proc;
|
|
|
|
wfc->wndClass.cbClsExtra = 0;
|
|
|
|
wfc->wndClass.cbWndExtra = 0;
|
|
|
|
wfc->wndClass.hCursor = wfc->cursor;
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
2013-06-16 06:57:21 +04:00
|
|
|
wfc->wndClass.lpszMenuName = NULL;
|
|
|
|
wfc->wndClass.lpszClassName = wfc->wndClassName;
|
|
|
|
wfc->wndClass.hInstance = hInstance;
|
|
|
|
wfc->wndClass.hIcon = wfc->icon;
|
|
|
|
wfc->wndClass.hIconSm = wfc->icon;
|
|
|
|
RegisterClassEx(&(wfc->wndClass));
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->keyboardThread =
|
|
|
|
CreateThread(NULL, 0, wf_keyboard_thread, (void*)wfc, 0, &wfc->keyboardThreadId);
|
2013-06-16 06:57:21 +04:00
|
|
|
|
|
|
|
if (!wfc->keyboardThread)
|
|
|
|
return -1;
|
|
|
|
|
2019-11-06 17:24:51 +03:00
|
|
|
wfc->thread = CreateThread(NULL, 0, wf_client_thread, (void*)instance, 0, &wfc->mainThreadId);
|
2013-06-16 06:57:21 +04:00
|
|
|
|
|
|
|
if (!wfc->thread)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:36:15 +03:00
|
|
|
static int wfreerdp_client_stop(rdpContext* context)
|
2013-06-16 06:57:21 +04:00
|
|
|
{
|
2019-11-06 17:24:51 +03:00
|
|
|
wfContext* wfc = (wfContext*)context;
|
2013-06-16 06:57:21 +04:00
|
|
|
|
2013-09-05 15:39:43 +04:00
|
|
|
if (wfc->thread)
|
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
PostThreadMessage(wfc->mainThreadId, WM_QUIT, 0, 0);
|
2013-09-05 15:39:43 +04:00
|
|
|
WaitForSingleObject(wfc->thread, INFINITE);
|
|
|
|
CloseHandle(wfc->thread);
|
|
|
|
wfc->thread = NULL;
|
|
|
|
wfc->mainThreadId = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wfc->keyboardThread)
|
|
|
|
{
|
2013-06-16 06:57:21 +04:00
|
|
|
PostThreadMessage(wfc->keyboardThreadId, WM_QUIT, 0, 0);
|
2013-09-05 15:39:43 +04:00
|
|
|
WaitForSingleObject(wfc->keyboardThread, INFINITE);
|
|
|
|
CloseHandle(wfc->keyboardThread);
|
|
|
|
wfc->keyboardThread = NULL;
|
|
|
|
wfc->keyboardThreadId = 0;
|
|
|
|
}
|
|
|
|
|
2013-06-16 06:57:21 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
|
|
|
|
{
|
|
|
|
pEntryPoints->Version = 1;
|
|
|
|
pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
|
|
|
|
pEntryPoints->GlobalInit = wfreerdp_client_global_init;
|
|
|
|
pEntryPoints->GlobalUninit = wfreerdp_client_global_uninit;
|
|
|
|
pEntryPoints->ContextSize = sizeof(wfContext);
|
|
|
|
pEntryPoints->ClientNew = wfreerdp_client_new;
|
|
|
|
pEntryPoints->ClientFree = wfreerdp_client_free;
|
|
|
|
pEntryPoints->ClientStart = wfreerdp_client_start;
|
|
|
|
pEntryPoints->ClientStop = wfreerdp_client_stop;
|
|
|
|
return 0;
|
2013-05-31 22:54:15 +04:00
|
|
|
}
|