2014-10-13 13:43:16 +04:00
|
|
|
/**
|
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
2014-11-17 18:36:28 +03:00
|
|
|
* Wayland Client
|
2014-10-13 13:43:16 +04:00
|
|
|
*
|
|
|
|
* Copyright 2014 Manuel Bachmann <tarnyko@tarnyko.net>
|
2016-04-05 18:07:45 +03:00
|
|
|
* Copyright 2016 Thincast Technologies GmbH
|
|
|
|
* Copyright 2016 Armin Novak <armin.novak@thincast.com>
|
2014-10-13 13:43:16 +04:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <errno.h>
|
2016-08-03 19:44:26 +03:00
|
|
|
#include <locale.h>
|
2019-01-25 13:47:15 +03:00
|
|
|
#include <float.h>
|
2014-10-13 13:43:16 +04:00
|
|
|
|
|
|
|
#include <freerdp/client/cmdline.h>
|
|
|
|
#include <freerdp/channels/channels.h>
|
|
|
|
#include <freerdp/gdi/gdi.h>
|
2016-08-03 19:44:26 +03:00
|
|
|
#include <freerdp/client.h>
|
|
|
|
#include <freerdp/utils/signal.h>
|
2017-07-13 14:29:00 +03:00
|
|
|
#include <freerdp/locale/keyboard.h>
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2016-01-07 01:56:05 +03:00
|
|
|
#include <linux/input.h>
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
#include <uwac/uwac.h>
|
|
|
|
|
2014-11-17 18:36:28 +03:00
|
|
|
#include "wlfreerdp.h"
|
2016-01-07 01:56:05 +03:00
|
|
|
#include "wlf_input.h"
|
2018-12-19 18:18:13 +03:00
|
|
|
#include "wlf_cliprdr.h"
|
2018-12-18 14:30:31 +03:00
|
|
|
#include "wlf_disp.h"
|
2016-08-03 19:44:26 +03:00
|
|
|
#include "wlf_channels.h"
|
2019-01-25 15:05:51 +03:00
|
|
|
#include "wlf_pointer.h"
|
2016-01-07 01:56:05 +03:00
|
|
|
|
2019-02-08 13:50:34 +03:00
|
|
|
#define TAG CLIENT_TAG("wayland")
|
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
static BOOL wl_begin_paint(rdpContext* context)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
2017-11-16 14:42:33 +03:00
|
|
|
|
|
|
|
if (!context || !context->gdi)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-10-13 13:43:16 +04:00
|
|
|
gdi = context->gdi;
|
2017-11-16 14:42:33 +03:00
|
|
|
|
|
|
|
if (!gdi->primary)
|
|
|
|
return FALSE;
|
|
|
|
|
2016-10-06 14:41:52 +03:00
|
|
|
gdi->primary->hdc->hwnd->invalid->null = TRUE;
|
2015-04-14 11:14:23 +03:00
|
|
|
return TRUE;
|
2014-10-13 13:43:16 +04:00
|
|
|
}
|
|
|
|
|
2019-01-24 13:19:20 +03:00
|
|
|
static BOOL wl_update_buffer(wlfContext* context_w, INT32 ix, INT32 iy, INT32 iw, INT32 ih)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
2016-08-03 19:44:26 +03:00
|
|
|
char* data;
|
2019-01-29 19:38:33 +03:00
|
|
|
UINT32 x, y, w, h;
|
2019-01-24 17:10:08 +03:00
|
|
|
UwacSize geometry;
|
|
|
|
size_t stride;
|
|
|
|
UwacReturnCode rc;
|
2019-01-25 13:47:15 +03:00
|
|
|
RECTANGLE_16 area;
|
2017-11-16 14:42:33 +03:00
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
if (!context_w)
|
2017-11-16 14:42:33 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2019-01-24 13:19:20 +03:00
|
|
|
if ((ix < 0) || (iy < 0) || (iw < 0) || (ih < 0))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
x = (UINT32)ix;
|
|
|
|
y = (UINT32)iy;
|
|
|
|
w = (UINT32)iw;
|
|
|
|
h = (UINT32)ih;
|
2019-01-24 17:10:08 +03:00
|
|
|
rc = UwacWindowGetDrawingBufferGeometry(context_w->window, &geometry, &stride);
|
2016-01-07 01:56:05 +03:00
|
|
|
data = UwacWindowGetDrawingBuffer(context_w->window);
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2019-01-24 17:10:08 +03:00
|
|
|
if (!data || (rc != UWAC_SUCCESS))
|
2016-02-25 02:41:19 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
gdi = context_w->context.gdi;
|
|
|
|
|
|
|
|
if (!gdi)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-24 17:10:08 +03:00
|
|
|
/* Ignore output if the surface size does not match. */
|
2019-02-07 16:39:15 +03:00
|
|
|
if (((INT64)x > geometry.width) || ((INT64)y > geometry.height))
|
2019-01-24 17:10:08 +03:00
|
|
|
return TRUE;
|
|
|
|
|
2019-01-25 13:47:15 +03:00
|
|
|
area.left = x;
|
|
|
|
area.top = y;
|
|
|
|
area.right = x + w;
|
|
|
|
area.bottom = y + h;
|
2019-01-24 17:10:08 +03:00
|
|
|
|
2019-01-25 13:47:15 +03:00
|
|
|
if (!wlf_copy_image(gdi->primary_buffer, gdi->stride, gdi->width, gdi->height,
|
|
|
|
data, stride, geometry.width, geometry.height, &area,
|
|
|
|
context_w->context.settings->SmartSizing))
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-29 15:14:45 +03:00
|
|
|
if (!wlf_scale_coordinates(&context_w->context, &x, &y, FALSE))
|
2019-01-25 13:47:15 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2019-01-29 15:14:45 +03:00
|
|
|
if (!wlf_scale_coordinates(&context_w->context, &w, &h, FALSE))
|
2019-01-25 13:47:15 +03:00
|
|
|
return FALSE;
|
2014-11-17 18:36:28 +03:00
|
|
|
|
2016-02-25 02:41:19 +03:00
|
|
|
if (UwacWindowAddDamage(context_w->window, x, y, w, h) != UWAC_SUCCESS)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-07-25 19:17:04 +03:00
|
|
|
if (UwacWindowSubmitBuffer(context_w->window, false) != UWAC_SUCCESS)
|
2019-01-24 14:01:40 +03:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
return TRUE;
|
2014-10-13 13:43:16 +04:00
|
|
|
}
|
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
static BOOL wl_end_paint(rdpContext* context)
|
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
|
|
|
wlfContext* context_w;
|
|
|
|
INT32 x, y;
|
2019-01-24 13:19:20 +03:00
|
|
|
INT32 w, h;
|
2019-01-18 16:38:51 +03:00
|
|
|
|
|
|
|
if (!context || !context->gdi || !context->gdi->primary)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
gdi = context->gdi;
|
|
|
|
|
|
|
|
if (gdi->primary->hdc->hwnd->invalid->null)
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
x = gdi->primary->hdc->hwnd->invalid->x;
|
|
|
|
y = gdi->primary->hdc->hwnd->invalid->y;
|
|
|
|
w = gdi->primary->hdc->hwnd->invalid->w;
|
|
|
|
h = gdi->primary->hdc->hwnd->invalid->h;
|
|
|
|
context_w = (wlfContext*) context;
|
|
|
|
return wl_update_buffer(context_w, x, y, w, h);
|
|
|
|
}
|
|
|
|
|
2019-01-22 12:29:08 +03:00
|
|
|
static BOOL wl_refresh_display(wlfContext* context)
|
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
|
|
|
|
|
|
|
if (!context || !context->context.gdi)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
gdi = context->context.gdi;
|
|
|
|
return wl_update_buffer(context, 0, 0, gdi->width, gdi->height);
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL wl_resize_display(rdpContext* context)
|
|
|
|
{
|
|
|
|
wlfContext* wlc = (wlfContext*)context;
|
|
|
|
rdpGdi* gdi = context->gdi;
|
|
|
|
rdpSettings* settings = context->settings;
|
|
|
|
|
|
|
|
if (!gdi_resize(gdi, settings->DesktopWidth, settings->DesktopHeight))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
return wl_refresh_display(wlc);
|
|
|
|
}
|
2016-01-07 01:56:05 +03:00
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
static BOOL wl_pre_connect(freerdp* instance)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2016-08-03 19:44:26 +03:00
|
|
|
rdpSettings* settings;
|
2014-11-17 18:36:28 +03:00
|
|
|
wlfContext* context;
|
2017-11-06 16:02:22 +03:00
|
|
|
UwacOutput* output;
|
2017-08-17 20:33:44 +03:00
|
|
|
UwacSize resolution;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!instance)
|
2015-04-20 17:20:16 +03:00
|
|
|
return FALSE;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2014-11-17 18:36:28 +03:00
|
|
|
context = (wlfContext*) instance->context;
|
2016-08-03 19:44:26 +03:00
|
|
|
settings = instance->settings;
|
|
|
|
|
|
|
|
if (!context || !settings)
|
2015-04-20 17:20:16 +03:00
|
|
|
return FALSE;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
settings->OsMajorType = OSMAJORTYPE_UNIX;
|
|
|
|
settings->OsMinorType = OSMINORTYPE_NATIVE_WAYLAND;
|
|
|
|
PubSub_SubscribeChannelConnected(instance->context->pubSub,
|
2018-02-14 12:14:33 +03:00
|
|
|
wlf_OnChannelConnectedEventHandler);
|
2016-08-03 19:44:26 +03:00
|
|
|
PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
|
2018-02-14 12:14:33 +03:00
|
|
|
wlf_OnChannelDisconnectedEventHandler);
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2017-08-17 20:33:44 +03:00
|
|
|
if (settings->Fullscreen)
|
|
|
|
{
|
|
|
|
// Use the resolution of the first display output
|
|
|
|
output = UwacDisplayGetOutput(context->display, 1);
|
2017-11-06 16:02:22 +03:00
|
|
|
|
2017-08-17 20:33:44 +03:00
|
|
|
if (output != NULL && UwacOutputGetResolution(output, &resolution) == UWAC_SUCCESS)
|
|
|
|
{
|
|
|
|
settings->DesktopWidth = (UINT32) resolution.width;
|
|
|
|
settings->DesktopHeight = (UINT32) resolution.height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WLog_WARN(TAG, "Failed to get output resolution! Check your display settings");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!freerdp_client_load_addins(instance->context->channels,
|
|
|
|
instance->settings))
|
|
|
|
return FALSE;
|
|
|
|
|
2014-10-13 13:43:16 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
static BOOL wl_post_connect(freerdp* instance)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
|
|
|
rdpGdi* gdi;
|
2016-01-07 01:56:05 +03:00
|
|
|
UwacWindow* window;
|
2014-11-17 18:36:28 +03:00
|
|
|
wlfContext* context;
|
2019-02-08 14:49:32 +03:00
|
|
|
rdpSettings* settings;
|
2019-01-24 13:19:20 +03:00
|
|
|
UINT32 w, h;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
if (!instance || !instance->context)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-02-08 14:49:32 +03:00
|
|
|
context = (wlfContext*) instance->context;
|
|
|
|
settings = instance->context->settings;
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
|
2015-05-08 22:39:23 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2014-10-13 13:43:16 +04:00
|
|
|
gdi = instance->context->gdi;
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2019-01-24 13:19:20 +03:00
|
|
|
if (!gdi || (gdi->width < 0) || (gdi->height < 0))
|
2015-04-20 17:20:16 +03:00
|
|
|
return FALSE;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2019-01-25 15:05:51 +03:00
|
|
|
if (!wlf_register_pointer(instance->context->graphics))
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-24 13:19:20 +03:00
|
|
|
w = (UINT32)gdi->width;
|
|
|
|
h = (UINT32)gdi->height;
|
2019-02-19 16:12:25 +03:00
|
|
|
|
2019-02-08 14:49:32 +03:00
|
|
|
if (settings->SmartSizing && !context->fullscreen)
|
|
|
|
{
|
|
|
|
if (settings->SmartSizingWidth > 0)
|
|
|
|
w = settings->SmartSizingWidth;
|
|
|
|
|
|
|
|
if (settings->SmartSizingHeight > 0)
|
|
|
|
h = settings->SmartSizingHeight;
|
|
|
|
}
|
|
|
|
|
2019-01-24 13:19:20 +03:00
|
|
|
context->window = window = UwacCreateWindowShm(context->display, w, h, WL_SHM_FORMAT_XRGB8888);
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
if (!window)
|
|
|
|
return FALSE;
|
2014-11-17 18:36:28 +03:00
|
|
|
|
2017-07-03 20:09:01 +03:00
|
|
|
UwacWindowSetFullscreenState(window, NULL, instance->context->settings->Fullscreen);
|
2016-01-07 01:56:05 +03:00
|
|
|
UwacWindowSetTitle(window, "FreeRDP");
|
2019-01-24 13:19:20 +03:00
|
|
|
UwacWindowSetOpaqueRegion(context->window, 0, 0, w, h);
|
2014-10-13 13:43:16 +04:00
|
|
|
instance->update->BeginPaint = wl_begin_paint;
|
|
|
|
instance->update->EndPaint = wl_end_paint;
|
2019-01-22 12:29:08 +03:00
|
|
|
instance->update->DesktopResize = wl_resize_display;
|
2017-07-03 20:09:01 +03:00
|
|
|
freerdp_keyboard_init(instance->context->settings->KeyboardLayout);
|
2018-12-18 14:30:31 +03:00
|
|
|
|
|
|
|
if (!(context->disp = wlf_disp_new(context)))
|
|
|
|
return FALSE;
|
|
|
|
|
2018-12-19 18:18:13 +03:00
|
|
|
context->clipboard = wlf_clipboard_new(context);
|
|
|
|
|
|
|
|
if (!context->clipboard)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-24 14:01:40 +03:00
|
|
|
return wl_refresh_display(context);
|
2014-10-13 13:43:16 +04:00
|
|
|
}
|
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
static void wl_post_disconnect(freerdp* instance)
|
|
|
|
{
|
2016-08-03 19:44:26 +03:00
|
|
|
wlfContext* context;
|
|
|
|
|
2015-04-20 17:20:16 +03:00
|
|
|
if (!instance)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!instance->context)
|
|
|
|
return;
|
|
|
|
|
|
|
|
context = (wlfContext*) instance->context;
|
2016-01-07 01:56:05 +03:00
|
|
|
gdi_free(instance);
|
2018-12-19 18:18:13 +03:00
|
|
|
wlf_clipboard_free(context->clipboard);
|
2018-12-18 14:30:31 +03:00
|
|
|
wlf_disp_free(context->disp);
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2016-01-07 01:56:05 +03:00
|
|
|
if (context->window)
|
|
|
|
UwacDestroyWindow(&context->window);
|
|
|
|
}
|
2015-04-20 17:20:16 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
static BOOL handle_uwac_events(freerdp* instance, UwacDisplay* display)
|
|
|
|
{
|
2016-01-07 01:56:05 +03:00
|
|
|
UwacEvent event;
|
2016-08-03 19:44:26 +03:00
|
|
|
wlfContext* context;
|
2016-01-07 01:56:05 +03:00
|
|
|
|
|
|
|
if (UwacDisplayDispatch(display, 1) < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
context = (wlfContext*)instance->context;
|
|
|
|
|
2016-01-07 01:56:05 +03:00
|
|
|
while (UwacHasEvent(display))
|
|
|
|
{
|
|
|
|
if (UwacNextEvent(display, &event) != UWAC_SUCCESS)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/*printf("UWAC event type %d\n", event.type);*/
|
2016-08-03 19:44:26 +03:00
|
|
|
switch (event.type)
|
|
|
|
{
|
2019-01-25 15:05:51 +03:00
|
|
|
case UWAC_EVENT_NEW_SEAT:
|
|
|
|
context->seat = event.seat_new.seat;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_REMOVED_SEAT:
|
|
|
|
context->seat = NULL;
|
|
|
|
break;
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
case UWAC_EVENT_FRAME_DONE:
|
2019-07-25 19:17:04 +03:00
|
|
|
if (UwacWindowSubmitBuffer(context->window, false) != UWAC_SUCCESS)
|
2019-01-25 13:47:15 +03:00
|
|
|
return FALSE;
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_POINTER_ENTER:
|
|
|
|
if (!wlf_handle_pointer_enter(instance, &event.mouse_enter_leave))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_POINTER_MOTION:
|
|
|
|
if (!wlf_handle_pointer_motion(instance, &event.mouse_motion))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_POINTER_BUTTONS:
|
|
|
|
if (!wlf_handle_pointer_buttons(instance, &event.mouse_button))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_POINTER_AXIS:
|
|
|
|
if (!wlf_handle_pointer_axis(instance, &event.mouse_axis))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_KEY:
|
|
|
|
if (!wlf_handle_key(instance, &event.key))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UWAC_EVENT_KEYBOARD_ENTER:
|
2019-01-22 15:46:46 +03:00
|
|
|
if (instance->context->settings->GrabKeyboard)
|
|
|
|
UwacSeatInhibitShortcuts(event.keyboard_enter_leave.seat, true);
|
2019-01-25 13:47:15 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!wlf_keyboard_enter(instance, &event.keyboard_enter_leave))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
case UWAC_EVENT_CONFIGURE:
|
2018-12-18 14:30:31 +03:00
|
|
|
if (!wlf_disp_handle_configure(context->disp, event.configure.width, event.configure.height))
|
|
|
|
return FALSE;
|
|
|
|
|
2019-01-18 16:38:51 +03:00
|
|
|
if (!wl_refresh_display(context))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2018-12-19 18:18:13 +03:00
|
|
|
case UWAC_EVENT_CLIPBOARD_AVAILABLE:
|
|
|
|
case UWAC_EVENT_CLIPBOARD_OFFER:
|
|
|
|
case UWAC_EVENT_CLIPBOARD_SELECT:
|
|
|
|
if (!wlf_cliprdr_handle_event(context->clipboard, &event.clipboard))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
default:
|
|
|
|
break;
|
2016-01-07 01:56:05 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2016-01-07 01:56:05 +03:00
|
|
|
return TRUE;
|
2015-04-20 17:20:16 +03:00
|
|
|
}
|
|
|
|
|
2019-02-19 16:12:25 +03:00
|
|
|
static BOOL handle_window_events(freerdp* instance)
|
|
|
|
{
|
|
|
|
rdpSettings* settings;
|
|
|
|
|
|
|
|
if (!instance || !instance->settings)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
settings = instance->settings;
|
|
|
|
|
|
|
|
if (!settings->AsyncInput)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2015-04-22 12:05:29 +03:00
|
|
|
static int wlfreerdp_run(freerdp* instance)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2016-08-03 19:44:26 +03:00
|
|
|
wlfContext* context;
|
2015-04-22 12:05:29 +03:00
|
|
|
DWORD count;
|
|
|
|
HANDLE handles[64];
|
2017-11-16 14:42:33 +03:00
|
|
|
DWORD status = WAIT_ABANDONED;
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!instance)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
context = (wlfContext*)instance->context;
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
return -1;
|
|
|
|
|
2015-04-22 12:05:29 +03:00
|
|
|
if (!freerdp_connect(instance))
|
|
|
|
{
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(context->log, WLOG_ERROR, "Failed to connect");
|
2016-04-05 18:07:45 +03:00
|
|
|
return -1;
|
2015-04-22 12:05:29 +03:00
|
|
|
}
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2015-04-22 12:05:29 +03:00
|
|
|
while (!freerdp_shall_disconnect(instance))
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2016-08-03 19:44:26 +03:00
|
|
|
handles[0] = context->displayHandle;
|
2017-11-16 14:42:33 +03:00
|
|
|
count = freerdp_get_event_handles(instance->context, &handles[1], 63) + 1;
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
if (count <= 1)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(context->log, WLOG_ERROR, "Failed to get FreeRDP file descriptor");
|
2014-10-13 13:43:16 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
|
2016-08-03 19:44:26 +03:00
|
|
|
|
2015-04-22 12:05:29 +03:00
|
|
|
if (WAIT_FAILED == status)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(context->log, WLOG_ERROR, "%s: WaitForMultipleObjects failed", __FUNCTION__);
|
2014-10-13 13:43:16 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!handle_uwac_events(instance, context->display))
|
|
|
|
{
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(context->log, WLOG_ERROR, "error handling UWAC events");
|
2014-10-13 13:43:16 +04:00
|
|
|
break;
|
|
|
|
}
|
2016-01-07 01:56:05 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
if (freerdp_check_event_handles(instance->context) != TRUE)
|
|
|
|
{
|
2019-02-19 16:12:25 +03:00
|
|
|
if (client_auto_reconnect_ex(instance, handle_window_events))
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Indicate an unsuccessful connection attempt if reconnect
|
|
|
|
* did not succeed and no other error was specified.
|
|
|
|
*/
|
|
|
|
if (freerdp_error_info(instance) == 0)
|
|
|
|
status = 42;
|
|
|
|
}
|
|
|
|
|
2017-11-06 16:02:22 +03:00
|
|
|
if (freerdp_get_last_error(instance->context) == FREERDP_ERROR_SUCCESS)
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(context->log, WLOG_ERROR, "Failed to check FreeRDP file descriptor");
|
2017-11-06 16:02:22 +03:00
|
|
|
|
2016-04-05 18:07:45 +03:00
|
|
|
break;
|
|
|
|
}
|
2014-10-13 13:43:16 +04:00
|
|
|
}
|
|
|
|
|
2015-01-20 13:24:36 +03:00
|
|
|
freerdp_disconnect(instance);
|
2017-11-16 14:42:33 +03:00
|
|
|
return status;
|
2014-10-13 13:43:16 +04:00
|
|
|
}
|
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
static BOOL wlf_client_global_init(void)
|
2014-10-13 13:43:16 +04:00
|
|
|
{
|
2016-08-03 19:44:26 +03:00
|
|
|
setlocale(LC_ALL, "");
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (freerdp_handle_signals() != 0)
|
|
|
|
return FALSE;
|
2016-01-07 01:56:05 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
return TRUE;
|
|
|
|
}
|
2016-01-07 01:56:05 +03:00
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
static void wlf_client_global_uninit(void)
|
2016-08-03 19:44:26 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-11-16 14:42:33 +03:00
|
|
|
static int wlf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
|
|
|
|
{
|
|
|
|
wlfContext* wlf;
|
|
|
|
const char* str_data = freerdp_get_logon_error_info_data(data);
|
|
|
|
const char* str_type = freerdp_get_logon_error_info_type(type);
|
|
|
|
|
|
|
|
if (!instance || !instance->context)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
wlf = (wlfContext*) instance->context;
|
2018-12-18 14:30:31 +03:00
|
|
|
WLog_Print(wlf->log, WLOG_INFO, "Logon Error Info %s [%s]", str_data, str_type);
|
2017-11-16 14:42:33 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
static BOOL wlf_client_new(freerdp* instance, rdpContext* context)
|
|
|
|
{
|
|
|
|
UwacReturnCode status;
|
|
|
|
wlfContext* wfl = (wlfContext*) context;
|
|
|
|
|
|
|
|
if (!instance || !context)
|
|
|
|
return FALSE;
|
|
|
|
|
2014-10-13 13:43:16 +04:00
|
|
|
instance->PreConnect = wl_pre_connect;
|
|
|
|
instance->PostConnect = wl_post_connect;
|
2015-04-20 17:20:16 +03:00
|
|
|
instance->PostDisconnect = wl_post_disconnect;
|
2015-12-17 18:43:55 +03:00
|
|
|
instance->Authenticate = client_cli_authenticate;
|
|
|
|
instance->GatewayAuthenticate = client_cli_gw_authenticate;
|
2018-11-30 13:04:20 +03:00
|
|
|
instance->VerifyCertificateEx = client_cli_verify_certificate_ex;
|
|
|
|
instance->VerifyChangedCertificateEx = client_cli_verify_changed_certificate_ex;
|
2017-11-16 14:42:33 +03:00
|
|
|
instance->LogonErrorInfo = wlf_logon_error_info;
|
2018-12-18 14:30:31 +03:00
|
|
|
wfl->log = WLog_Get(TAG);
|
2016-08-03 19:44:26 +03:00
|
|
|
wfl->display = UwacOpenDisplay(NULL, &status);
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2018-12-18 14:30:31 +03:00
|
|
|
if (!wfl->display || (status != UWAC_SUCCESS) || !wfl->log)
|
2016-08-03 19:44:26 +03:00
|
|
|
return FALSE;
|
2015-04-20 17:20:16 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
wfl->displayHandle = CreateFileDescriptorEvent(NULL, FALSE, FALSE,
|
|
|
|
UwacDisplayGetFd(wfl->display), WINPR_FD_READ);
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (!wfl->displayHandle)
|
|
|
|
return FALSE;
|
2014-10-16 17:44:48 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
return TRUE;
|
|
|
|
}
|
2014-10-13 13:43:16 +04:00
|
|
|
|
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
static void wlf_client_free(freerdp* instance, rdpContext* context)
|
|
|
|
{
|
|
|
|
wlfContext* wlf = (wlfContext*) instance->context;
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (wlf->display)
|
|
|
|
UwacCloseDisplay(&wlf->display);
|
2014-10-13 13:43:16 +04:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
if (wlf->displayHandle)
|
|
|
|
CloseHandle(wlf->displayHandle);
|
|
|
|
}
|
2015-04-20 17:20:16 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
static int wfl_client_start(rdpContext* context)
|
|
|
|
{
|
2019-01-24 13:19:20 +03:00
|
|
|
WINPR_UNUSED(context);
|
2016-08-03 19:44:26 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2015-04-20 17:20:16 +03:00
|
|
|
|
2016-08-03 19:44:26 +03:00
|
|
|
static int wfl_client_stop(rdpContext* context)
|
|
|
|
{
|
2019-01-24 13:19:20 +03:00
|
|
|
WINPR_UNUSED(context);
|
2014-10-13 13:43:16 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2016-08-03 19:44:26 +03:00
|
|
|
|
|
|
|
static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
|
|
|
|
{
|
|
|
|
ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
|
|
|
|
pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
|
|
|
|
pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
|
|
|
|
pEntryPoints->GlobalInit = wlf_client_global_init;
|
|
|
|
pEntryPoints->GlobalUninit = wlf_client_global_uninit;
|
|
|
|
pEntryPoints->ContextSize = sizeof(wlfContext);
|
|
|
|
pEntryPoints->ClientNew = wlf_client_new;
|
|
|
|
pEntryPoints->ClientFree = wlf_client_free;
|
|
|
|
pEntryPoints->ClientStart = wfl_client_start;
|
|
|
|
pEntryPoints->ClientStop = wfl_client_stop;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char* argv[])
|
|
|
|
{
|
|
|
|
int rc = -1;
|
2019-01-24 13:19:20 +03:00
|
|
|
int status;
|
2016-08-03 19:44:26 +03:00
|
|
|
RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
|
|
|
|
rdpContext* context;
|
|
|
|
RdpClientEntry(&clientEntryPoints);
|
|
|
|
context = freerdp_client_context_new(&clientEntryPoints);
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
status = freerdp_client_settings_parse_command_line(context->settings, argc,
|
|
|
|
argv, FALSE);
|
|
|
|
status = freerdp_client_settings_command_line_status_print(context->settings,
|
|
|
|
status, argc, argv);
|
|
|
|
|
|
|
|
if (status)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (freerdp_client_start(context) != 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
rc = wlfreerdp_run(context->instance);
|
|
|
|
|
|
|
|
if (freerdp_client_stop(context) != 0)
|
|
|
|
rc = -1;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
freerdp_client_context_free(context);
|
|
|
|
return rc;
|
|
|
|
}
|
2019-01-25 13:47:15 +03:00
|
|
|
|
|
|
|
BOOL wlf_copy_image(const void* src, size_t srcStride, size_t srcWidth, size_t srcHeight,
|
|
|
|
void* dst, size_t dstStride, size_t dstWidth, size_t dstHeight,
|
|
|
|
const RECTANGLE_16* area, BOOL scale)
|
|
|
|
{
|
|
|
|
BOOL rc = FALSE;
|
|
|
|
|
|
|
|
if (!src || !dst || !area)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (scale)
|
|
|
|
{
|
2019-05-06 14:18:31 +03:00
|
|
|
return freerdp_image_scale(dst, PIXEL_FORMAT_BGRA32, dstStride, 0, 0, dstWidth, dstHeight,
|
|
|
|
src, PIXEL_FORMAT_BGRA32, srcStride, 0, 0, srcWidth, srcHeight);
|
2019-01-25 13:47:15 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
const size_t baseSrcOffset = area->top * srcStride + area->left * 4;
|
|
|
|
const size_t baseDstOffset = area->top * dstStride + area->left * 4;
|
2019-02-07 16:39:15 +03:00
|
|
|
const size_t width = MIN((size_t)area->right - area->left, dstWidth - area->left);
|
|
|
|
const size_t height = MIN((size_t)area->bottom - area->top, dstHeight - area->top);
|
2019-01-25 13:47:15 +03:00
|
|
|
const BYTE* psrc = (const BYTE*)src;
|
|
|
|
BYTE* pdst = (BYTE*)dst;
|
|
|
|
|
|
|
|
for (i = 0; i < height; i++)
|
|
|
|
{
|
|
|
|
const size_t srcOffset = i * srcStride + baseSrcOffset;
|
|
|
|
const size_t dstOffset = i * dstStride + baseDstOffset;
|
|
|
|
memcpy(&pdst[dstOffset], &psrc[srcOffset], width * 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2019-01-29 15:14:45 +03:00
|
|
|
BOOL wlf_scale_coordinates(rdpContext* context, UINT32* px, UINT32* py, BOOL fromLocalToRDP)
|
2019-01-25 13:47:15 +03:00
|
|
|
{
|
|
|
|
wlfContext* wlf = (wlfContext*)context;
|
|
|
|
rdpGdi* gdi;
|
|
|
|
UwacSize geometry;
|
|
|
|
double sx, sy;
|
|
|
|
|
|
|
|
if (!context || !px || !py || !context->gdi)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (!context->settings->SmartSizing)
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
gdi = context->gdi;
|
|
|
|
|
|
|
|
if (UwacWindowGetDrawingBufferGeometry(wlf->window, &geometry, NULL) != UWAC_SUCCESS)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
sx = geometry.width / (double)gdi->width;
|
|
|
|
sy = geometry.height / (double)gdi->height;
|
2019-01-29 15:14:45 +03:00
|
|
|
|
|
|
|
if (!fromLocalToRDP)
|
|
|
|
{
|
|
|
|
*px *= sx;
|
|
|
|
*py *= sy;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*px /= sx;
|
|
|
|
*py /= sy;
|
|
|
|
}
|
|
|
|
|
2019-01-25 13:47:15 +03:00
|
|
|
return TRUE;
|
|
|
|
}
|