/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 *

 * Copyright 2011-2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2017 Armin Novak <armin.novak@thincast.com>

 * Copyright 2017 Thincast Technologies GmbH

 *

 * 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 <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <sys/select.h>

#include <sys/signal.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <winpr/crt.h>

#include <winpr/path.h>

#include <winpr/synch.h>

#include <winpr/image.h>

#include <winpr/sysinfo.h>

#include <freerdp/log.h>

#include <freerdp/codec/color.h>

#include <freerdp/codec/region.h>

#include "x11_shadow.h"

#define TAG SERVER_TAG("shadow.x11")

static UINT32 x11_shadow_enum_monitors(MONITOR_DEF* monitors, UINT32 maxMonitors);

#ifdef WITH_PAM

#include <security/pam_appl.h>

struct _SHADOW_PAM_AUTH_DATA

{

	const char* user;

	const char* domain;

	const char* password;

};

typedef struct _SHADOW_PAM_AUTH_DATA SHADOW_PAM_AUTH_DATA;

struct _SHADOW_PAM_AUTH_INFO

{

	char* service_name;

	pam_handle_t* handle;

	struct pam_conv pamc;

	SHADOW_PAM_AUTH_DATA appdata;

};

typedef struct _SHADOW_PAM_AUTH_INFO SHADOW_PAM_AUTH_INFO;

static int x11_shadow_pam_conv(int num_msg, const struct pam_message** msg,

                               struct pam_response** resp, void* appdata_ptr)

{

	int index;

	int pam_status = PAM_CONV_ERR;

	SHADOW_PAM_AUTH_DATA* appdata;

	struct pam_response* response;

	appdata = (SHADOW_PAM_AUTH_DATA*)appdata_ptr;

	if (!(response = (struct pam_response*)calloc(num_msg, sizeof(struct pam_response))))

		return PAM_BUF_ERR;

	for (index = 0; index < num_msg; index++)

	{

		switch (msg[index]->msg_style)

		{

			case PAM_PROMPT_ECHO_ON:

				response[index].resp = _strdup(appdata->user);

				if (!response[index].resp)

					goto out_fail;

				response[index].resp_retcode = PAM_SUCCESS;

				break;

			case PAM_PROMPT_ECHO_OFF:

				response[index].resp = _strdup(appdata->password);

				if (!response[index].resp)

					goto out_fail;

				response[index].resp_retcode = PAM_SUCCESS;

				break;

			default:

				pam_status = PAM_CONV_ERR;

				goto out_fail;

		}

	}

	*resp = response;

	return PAM_SUCCESS;

out_fail:

	for (index = 0; index < num_msg; ++index)

	{

		if (response[index].resp)

		{

			memset(response[index].resp, 0, strlen(response[index].resp));

			free(response[index].resp);

		}

	}

	memset(response, 0, sizeof(struct pam_response) * num_msg);

	free(response);

	*resp = NULL;

	return pam_status;

}

static BOOL x11_shadow_pam_get_service_name(SHADOW_PAM_AUTH_INFO* info)

{

	size_t x;

	const char* base = "/etc/pam.d";

	const char* hints[] = { "lightdm", "gdm", "xdm", "login", "sshd" };

	for (x = 0; x < ARRAYSIZE(hints); x++)

	{

		char path[MAX_PATH];

		const char* hint = hints[x];

		_snprintf(path, sizeof(path), "%s/%s", base, hint);

		if (PathFileExistsA(path))

		{

			info->service_name = _strdup(hint);

			return info->service_name != NULL;

		}

	}

	WLog_WARN(TAG, "Could not determine PAM service name");

	return FALSE;

}

static int x11_shadow_pam_authenticate(rdpShadowSubsystem* subsystem, rdpShadowClient* client,

                                       const char* user, const char* domain, const char* password)

{

	int pam_status;

	SHADOW_PAM_AUTH_INFO info = { 0 };

	WINPR_UNUSED(subsystem);

	WINPR_UNUSED(client);

	if (!x11_shadow_pam_get_service_name(&info))

		return -1;

	info.appdata.user = user;

	info.appdata.domain = domain;

	info.appdata.password = password;

	info.pamc.conv = &x11_shadow_pam_conv;

	info.pamc.appdata_ptr = &info.appdata;

	pam_status = pam_start(info.service_name, 0, &info.pamc, &info.handle);

	if (pam_status != PAM_SUCCESS)

	{

		WLog_ERR(TAG, "pam_start failure: %s", pam_strerror(info.handle, pam_status));

		return -1;

	}

	pam_status = pam_authenticate(info.handle, 0);

	if (pam_status != PAM_SUCCESS)

	{

		WLog_ERR(TAG, "pam_authenticate failure: %s", pam_strerror(info.handle, pam_status));

		return -1;

	}

	pam_status = pam_acct_mgmt(info.handle, 0);

	if (pam_status != PAM_SUCCESS)

	{

		WLog_ERR(TAG, "pam_acct_mgmt failure: %s", pam_strerror(info.handle, pam_status));

		return -1;

	}

	return 1;

}

#endif

static BOOL x11_shadow_input_synchronize_event(rdpShadowSubsystem* subsystem,

                                               rdpShadowClient* client, UINT32 flags)

{

	/* TODO: Implement */

	WLog_WARN(TAG, "%s not implemented", __FUNCTION__);

	return TRUE;

}

static BOOL x11_shadow_input_keyboard_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,

                                            UINT16 flags, UINT16 code)

{

#ifdef WITH_XTEST

	x11ShadowSubsystem* x11 = (x11ShadowSubsystem*)subsystem;

	DWORD vkcode;

	DWORD keycode;

	BOOL extended = FALSE;

	if (!client || !subsystem)

		return FALSE;

	if (flags & KBD_FLAGS_EXTENDED)

		extended = TRUE;

	if (extended)

		code |= KBDEXT;

	vkcode = GetVirtualKeyCodeFromVirtualScanCode(code, 4);

	if (extended)

		vkcode |= KBDEXT;

	keycode = GetKeycodeFromVirtualKeyCode(vkcode, KEYCODE_TYPE_EVDEV);

	if (keycode != 0)

	{

		XLockDisplay(x11->display);

		XTestGrabControl(x11->display, True);

		if (flags & KBD_FLAGS_DOWN)

			XTestFakeKeyEvent(x11->display, keycode, True, CurrentTime);

		else if (flags & KBD_FLAGS_RELEASE)

			XTestFakeKeyEvent(x11->display, keycode, False, CurrentTime);

		XTestGrabControl(x11->display, False);

		XFlush(x11->display);

		XUnlockDisplay(x11->display);

	}

#endif

	return TRUE;

}

static BOOL x11_shadow_input_unicode_keyboard_event(rdpShadowSubsystem* subsystem,

                                                    rdpShadowClient* client, UINT16 flags,

                                                    UINT16 code)

{

	/* TODO: Implement */

	WLog_WARN(TAG, "%s not implemented", __FUNCTION__);

	return TRUE;

}

static BOOL x11_shadow_input_mouse_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,

                                         UINT16 flags, UINT16 x, UINT16 y)

{

#ifdef WITH_XTEST

	x11ShadowSubsystem* x11 = (x11ShadowSubsystem*)subsystem;

	int button = 0;

	BOOL down = FALSE;

	rdpShadowServer* server;

	rdpShadowSurface* surface;

	if (!subsystem || !client)

		return FALSE;

	server = subsystem->server;

	if (!server)

		return FALSE;

	surface = server->surface;

	if (!surface)

		return FALSE;

	x11->lastMouseClient = client;

	x += surface->x;

	y += surface->y;

	XLockDisplay(x11->display);

	XTestGrabControl(x11->display, True);

	if (flags & PTR_FLAGS_WHEEL)

	{

		BOOL negative = FALSE;

		if (flags & PTR_FLAGS_WHEEL_NEGATIVE)

			negative = TRUE;

		button = (negative) ? 5 : 4;

		XTestFakeButtonEvent(x11->display, button, True, CurrentTime);

		XTestFakeButtonEvent(x11->display, button, False, CurrentTime);

	}

	else

	{

		if (flags & PTR_FLAGS_MOVE)

			XTestFakeMotionEvent(x11->display, 0, x, y, CurrentTime);

		if (flags & PTR_FLAGS_BUTTON1)

			button = 1;

		else if (flags & PTR_FLAGS_BUTTON2)

			button = 3;

		else if (flags & PTR_FLAGS_BUTTON3)

			button = 2;

		if (flags & PTR_FLAGS_DOWN)

			down = TRUE;

		if (button)

			XTestFakeButtonEvent(x11->display, button, down, CurrentTime);

	}

	XTestGrabControl(x11->display, False);

	XFlush(x11->display);

	XUnlockDisplay(x11->display);

#endif

	return TRUE;

}

static BOOL x11_shadow_input_extended_mouse_event(rdpShadowSubsystem* subsystem,

                                                  rdpShadowClient* client, UINT16 flags, UINT16 x,

                                                  UINT16 y)

{

#ifdef WITH_XTEST

	x11ShadowSubsystem* x11 = (x11ShadowSubsystem*)subsystem;

	int button = 0;

	BOOL down = FALSE;

	rdpShadowServer* server;

	rdpShadowSurface* surface;

	if (!subsystem || !client)

		return FALSE;

	server = subsystem->server;

	if (!server)

		return FALSE;

	surface = server->surface;

	if (!surface)

		return FALSE;

	x11->lastMouseClient = client;

	x += surface->x;

	y += surface->y;

	XLockDisplay(x11->display);

	XTestGrabControl(x11->display, True);

	XTestFakeMotionEvent(x11->display, 0, x, y, CurrentTime);

	if (flags & PTR_XFLAGS_BUTTON1)

		button = 8;

	else if (flags & PTR_XFLAGS_BUTTON2)

		button = 9;

	if (flags & PTR_XFLAGS_DOWN)

		down = TRUE;

	if (button)

		XTestFakeButtonEvent(x11->display, button, down, CurrentTime);

	XTestGrabControl(x11->display, False);

	XFlush(x11->display);

	XUnlockDisplay(x11->display);

#endif

	return TRUE;

}

static void x11_shadow_message_free(UINT32 id, SHADOW_MSG_OUT* msg)

{

	switch (id)

	{

		case SHADOW_MSG_OUT_POINTER_POSITION_UPDATE_ID:

			free(msg);

			break;

		case SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID:

			free(((SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE*)msg)->xorMaskData);

			free(((SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE*)msg)->andMaskData);

			free(msg);

			break;

		default:

			WLog_ERR(TAG, "Unknown message id: %" PRIu32 "", id);

			free(msg);

			break;

	}

}

static int x11_shadow_pointer_position_update(x11ShadowSubsystem* subsystem)

{

	UINT32 msgId = SHADOW_MSG_OUT_POINTER_POSITION_UPDATE_ID;

	rdpShadowServer* server;

	SHADOW_MSG_OUT_POINTER_POSITION_UPDATE templateMsg;

	int count = 0;

	int index = 0;

	if (!subsystem || !subsystem->common.server || !subsystem->common.server->clients)

		return -1;

	templateMsg.xPos = subsystem->common.pointerX;

	templateMsg.yPos = subsystem->common.pointerY;

	templateMsg.common.Free = x11_shadow_message_free;

	server = subsystem->common.server;

	ArrayList_Lock(server->clients);

	for (index = 0; index < ArrayList_Count(server->clients); index++)

	{

		SHADOW_MSG_OUT_POINTER_POSITION_UPDATE* msg;

		rdpShadowClient* client = (rdpShadowClient*)ArrayList_GetItem(server->clients, index);

		/* Skip the client which send us the latest mouse event */

		if (client == subsystem->lastMouseClient)

			continue;

		msg = malloc(sizeof(templateMsg));

		if (!msg)

		{

			count = -1;

			break;

		}

		memcpy(msg, &templateMsg, sizeof(templateMsg));

		if (shadow_client_post_msg(client, NULL, msgId, (SHADOW_MSG_OUT*)msg, NULL))

			count++;

	}

	ArrayList_Unlock(server->clients);

	return count;

}

static int x11_shadow_pointer_alpha_update(x11ShadowSubsystem* subsystem)

{

	SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE* msg;

	UINT32 msgId = SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE_ID;

	msg = (SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE*)calloc(1,

	                                                   sizeof(SHADOW_MSG_OUT_POINTER_ALPHA_UPDATE));

	if (!msg)

		return -1;

	msg->xHot = subsystem->cursorHotX;

	msg->yHot = subsystem->cursorHotY;

	msg->width = subsystem->cursorWidth;

	msg->height = subsystem->cursorHeight;

	if (shadow_subsystem_pointer_convert_alpha_pointer_data(subsystem->cursorPixels, TRUE,

	                                                        msg->width, msg->height, msg) < 0)

	{

		free(msg);

		return -1;

	}

	msg->common.Free = x11_shadow_message_free;

	return shadow_client_boardcast_msg(subsystem->common.server, NULL, msgId, (SHADOW_MSG_OUT*)msg,

	                                   NULL)

	           ? 1

	           : -1;

}

static int x11_shadow_query_cursor(x11ShadowSubsystem* subsystem, BOOL getImage)

{

	int x = 0, y = 0, n, k;

	rdpShadowServer* server;

	rdpShadowSurface* surface;

	server = subsystem->common.server;

	surface = server->surface;

	if (getImage)

	{

#ifdef WITH_XFIXES

		UINT32* pDstPixel;

		XFixesCursorImage* ci;

		XLockDisplay(subsystem->display);

		ci = XFixesGetCursorImage(subsystem->display);

		XUnlockDisplay(subsystem->display);

		if (!ci)

			return -1;

		x = ci->x;

		y = ci->y;

		if (ci->width > subsystem->cursorMaxWidth)

			return -1;

		if (ci->height > subsystem->cursorMaxHeight)

			return -1;

		subsystem->cursorHotX = ci->xhot;

		subsystem->cursorHotY = ci->yhot;

		subsystem->cursorWidth = ci->width;

		subsystem->cursorHeight = ci->height;

		subsystem->cursorId = ci->cursor_serial;

		n = ci->width * ci->height;

		pDstPixel = (UINT32*)subsystem->cursorPixels;

		for (k = 0; k < n; k++)

		{

			/* XFixesCursorImage.pixels is in *unsigned long*, which may be 8 bytes */

			*pDstPixel++ = (UINT32)ci->pixels[k];

		}

		XFree(ci);

		x11_shadow_pointer_alpha_update(subsystem);

#endif

	}

	else

	{

		UINT32 mask;

		int win_x, win_y;

		int root_x, root_y;

		Window root, child;

		XLockDisplay(subsystem->display);

		if (!XQueryPointer(subsystem->display, subsystem->root_window, &root, &child, &root_x,

		                   &root_y, &win_x, &win_y, &mask))

		{

			XUnlockDisplay(subsystem->display);

			return -1;

		}

		XUnlockDisplay(subsystem->display);

		x = root_x;

		y = root_y;

	}

	/* Convert to offset based on current surface */

	if (surface)

	{

		x -= surface->x;

		y -= surface->y;

	}

	if ((x != (INT64)subsystem->common.pointerX) || (y != (INT64)subsystem->common.pointerY))

	{

		subsystem->common.pointerX = x;

		subsystem->common.pointerY = y;

		x11_shadow_pointer_position_update(subsystem);

	}

	return 1;

}

static int x11_shadow_handle_xevent(x11ShadowSubsystem* subsystem, XEvent* xevent)

{

	if (xevent->type == MotionNotify)

	{

	}

#ifdef WITH_XFIXES

	else if (xevent->type == subsystem->xfixes_cursor_notify_event)

	{

		x11_shadow_query_cursor(subsystem, TRUE);

	}

#endif

	else

	{

	}

	return 1;

}

static void x11_shadow_validate_region(x11ShadowSubsystem* subsystem, int x, int y, int width,

                                       int height)

{

	XRectangle region;

	if (!subsystem->use_xfixes || !subsystem->use_xdamage)

		return;

	region.x = x;

	region.y = y;

	region.width = width;

	region.height = height;

#ifdef WITH_XFIXES

	XLockDisplay(subsystem->display);

	XFixesSetRegion(subsystem->display, subsystem->xdamage_region, &region, 1);

	XDamageSubtract(subsystem->display, subsystem->xdamage, subsystem->xdamage_region, None);

	XUnlockDisplay(subsystem->display);

#endif

}

static int x11_shadow_blend_cursor(x11ShadowSubsystem* subsystem)

{

	int x, y;

	int nXSrc;

	int nYSrc;

	int nXDst;

	int nYDst;

	int nWidth;

	int nHeight;

	int nSrcStep;

	int nDstStep;

	BYTE* pSrcData;

	BYTE* pDstData;

	BYTE A, R, G, B;

	rdpShadowSurface* surface;

	if (!subsystem)

		return -1;

	surface = subsystem->common.server->surface;

	nXSrc = 0;

	nYSrc = 0;

	nWidth = subsystem->cursorWidth;

	nHeight = subsystem->cursorHeight;

	nXDst = subsystem->common.pointerX - subsystem->cursorHotX;

	nYDst = subsystem->common.pointerY - subsystem->cursorHotY;

	if (nXDst >= surface->width)

		return 1;

	if (nXDst < 0)

	{

		nXDst *= -1;

		if (nXDst >= nWidth)

			return 1;

		nXSrc = nXDst;

		nWidth -= nXDst;

		nXDst = 0;

	}

	if (nYDst >= surface->height)

		return 1;

	if (nYDst < 0)

	{

		nYDst *= -1;

		if (nYDst >= nHeight)

			return 1;

		nYSrc = nYDst;

		nHeight -= nYDst;

		nYDst = 0;

	}

	if ((nXDst + nWidth) > surface->width)

		nWidth = surface->width - nXDst;

	if ((nYDst + nHeight) > surface->height)

		nHeight = surface->height - nYDst;

	pSrcData = subsystem->cursorPixels;

	nSrcStep = subsystem->cursorWidth * 4;

	pDstData = surface->data;

	nDstStep = surface->scanline;

	for (y = 0; y < nHeight; y++)

	{

		const BYTE* pSrcPixel = &pSrcData[((nYSrc + y) * nSrcStep) + (nXSrc * 4)];

		BYTE* pDstPixel = &pDstData[((nYDst + y) * nDstStep) + (nXDst * 4)];

		for (x = 0; x < nWidth; x++)

		{

			B = *pSrcPixel++;

			G = *pSrcPixel++;

			R = *pSrcPixel++;

			A = *pSrcPixel++;

			if (A == 0xFF)

			{

				pDstPixel[0] = B;

				pDstPixel[1] = G;

				pDstPixel[2] = R;

			}

			else

			{

				pDstPixel[0] = B + (pDstPixel[0] * (0xFF - A) + (0xFF / 2)) / 0xFF;

				pDstPixel[1] = G + (pDstPixel[1] * (0xFF - A) + (0xFF / 2)) / 0xFF;

				pDstPixel[2] = R + (pDstPixel[2] * (0xFF - A) + (0xFF / 2)) / 0xFF;

			}

			pDstPixel[3] = 0xFF;

			pDstPixel += 4;

		}

	}

	return 1;

}

static BOOL x11_shadow_check_resize(x11ShadowSubsystem* subsystem)

{

	MONITOR_DEF* virtualScreen;

	XWindowAttributes attr;

	XLockDisplay(subsystem->display);

	XGetWindowAttributes(subsystem->display, subsystem->root_window, &attr);

	XUnlockDisplay(subsystem->display);

	if (attr.width != (INT64)subsystem->width || attr.height != (INT64)subsystem->height)

	{

		/* Screen size changed. Refresh monitor definitions and trigger screen resize */

		subsystem->common.numMonitors = x11_shadow_enum_monitors(subsystem->common.monitors, 16);

		shadow_screen_resize(subsystem->common.server->screen);

		subsystem->width = attr.width;

		subsystem->height = attr.height;

		virtualScreen = &(subsystem->common.virtualScreen);

		virtualScreen->left = 0;

		virtualScreen->top = 0;

		virtualScreen->right = subsystem->width;

		virtualScreen->bottom = subsystem->height;

		virtualScreen->flags = 1;

		return TRUE;

	}

	return FALSE;

}

static int x11_shadow_error_handler_for_capture(Display* display, XErrorEvent* event)

{

	char msg[256];

	XGetErrorText(display, event->error_code, (char*)&msg, sizeof(msg));

	WLog_ERR(TAG, "X11 error: %s Error code: %x, request code: %x, minor code: %x", msg,

	         event->error_code, event->request_code, event->minor_code);

	/* Ignore BAD MATCH error during image capture. Abort in other case */

	if (event->error_code != BadMatch)

	{

		abort();

	}

	return 0;

}

static int x11_shadow_screen_grab(x11ShadowSubsystem* subsystem)

{

	int rc = 0;

	int count;

	int status;

	int x, y;

	int width, height;

	XImage* image;

	rdpShadowServer* server;

	rdpShadowSurface* surface;

	RECTANGLE_16 invalidRect;

	RECTANGLE_16 surfaceRect;

	const RECTANGLE_16* extents;

	server = subsystem->common.server;

	surface = server->surface;

	count = ArrayList_Count(server->clients);

	if (count < 1)

		return 1;

	EnterCriticalSection(&surface->lock);

	surfaceRect.left = 0;

	surfaceRect.top = 0;

	surfaceRect.right = surface->width;

	surfaceRect.bottom = surface->height;

	LeaveCriticalSection(&surface->lock);

	XLockDisplay(subsystem->display);

	/*

	 * Ignore BadMatch error during image capture. The screen size may be

	 * changed outside. We will resize to correct resolution at next frame

	 */

	XSetErrorHandler(x11_shadow_error_handler_for_capture);

	if (subsystem->use_xshm)

	{

		image = subsystem->fb_image;

		XCopyArea(subsystem->display, subsystem->root_window, subsystem->fb_pixmap,

		          subsystem->xshm_gc, 0, 0, subsystem->width, subsystem->height, 0, 0);

		EnterCriticalSection(&surface->lock);

		status = shadow_capture_compare(surface->data, surface->scanline, surface->width,

		                                surface->height, (BYTE*)&(image->data[surface->width * 4]),

		                                image->bytes_per_line, &invalidRect);

		LeaveCriticalSection(&surface->lock);

	}

	else

	{

		EnterCriticalSection(&surface->lock);

		image = XGetImage(subsystem->display, subsystem->root_window, surface->x, surface->y,

		                  surface->width, surface->height, AllPlanes, ZPixmap);

		if (image)

		{

			status = shadow_capture_compare(surface->data, surface->scanline, surface->width,

			                                surface->height, (BYTE*)image->data,

			                                image->bytes_per_line, &invalidRect);

		}

		LeaveCriticalSection(&surface->lock);

		if (!image)

		{

			/*

			 * BadMatch error happened. The size may have been changed again.

			 * Give up this frame and we will resize again in next frame

			 */

			goto fail_capture;

		}

	}

	/* Restore the default error handler */

	XSetErrorHandler(NULL);

	XSync(subsystem->display, False);

	XUnlockDisplay(subsystem->display);

	if (status)

	{

		BOOL empty;

		EnterCriticalSection(&surface->lock);

		region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);

		region16_intersect_rect(&(surface->invalidRegion), &(surface->invalidRegion), &surfaceRect);

		empty = region16_is_empty(&(surface->invalidRegion));

		LeaveCriticalSection(&surface->lock);

		if (!empty)

		{

			BOOL success;

			EnterCriticalSection(&surface->lock);

			extents = region16_extents(&(surface->invalidRegion));

			x = extents->left;

			y = extents->top;

			width = extents->right - extents->left;

			height = extents->bottom - extents->top;

			success = freerdp_image_copy(surface->data, surface->format, surface->scanline, x, y,

			                             width, height, (BYTE*)image->data, PIXEL_FORMAT_BGRX32,

			                             image->bytes_per_line, x, y, NULL, FREERDP_FLIP_NONE);

			LeaveCriticalSection(&surface->lock);

			if (!success)

				goto fail_capture;

			// x11_shadow_blend_cursor(subsystem);

			count = ArrayList_Count(server->clients);

			shadow_subsystem_frame_update(&subsystem->common);

			if (count == 1)

			{

				rdpShadowClient* client;

				client = (rdpShadowClient*)ArrayList_GetItem(server->clients, 0);

				if (client)

					subsystem->common.captureFrameRate =

					    shadow_encoder_preferred_fps(client->encoder);

			}

			EnterCriticalSection(&surface->lock);

			region16_clear(&(surface->invalidRegion));

			LeaveCriticalSection(&surface->lock);

		}

	}

	rc = 1;

fail_capture:

	if (!subsystem->use_xshm && image)

		XDestroyImage(image);

	if (rc != 1)

	{

		XSetErrorHandler(NULL);

		XSync(subsystem->display, False);

		XUnlockDisplay(subsystem->display);

	}

	return rc;

}

static int x11_shadow_subsystem_process_message(x11ShadowSubsystem* subsystem, wMessage* message)

{

	switch (message->id)

	{

		case SHADOW_MSG_IN_REFRESH_REQUEST_ID:

			shadow_subsystem_frame_update((rdpShadowSubsystem*)subsystem);

			break;

		default: