/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * X11 Clipboard Redirection

 *

 * Copyright 2010-2011 Vic Lee

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.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

 *

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

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdlib.h>

#include <X11/Xlib.h>

#include <X11/Xatom.h>

#ifdef WITH_XFIXES

#include <X11/extensions/Xfixes.h>

#endif

#include <winpr/crt.h>

#include <winpr/image.h>

#include <winpr/stream.h>

#include <winpr/clipboard.h>

#include <freerdp/log.h>

#include <freerdp/client/cliprdr.h>

#include <freerdp/channels/channels.h>

#include <freerdp/channels/cliprdr.h>

#include "xf_cliprdr.h"

#define TAG CLIENT_TAG("x11")

#define MAX_CLIPBOARD_FORMATS 255

struct xf_cliprdr_format

{

	Atom atom;

	UINT32 formatId;

	char* formatName;

};

typedef struct xf_cliprdr_format xfCliprdrFormat;

struct xf_clipboard

{

	xfContext* xfc;

	rdpChannels* channels;

	CliprdrClientContext* context;

	wClipboard* system;

	wClipboardDelegate* delegate;

	Window root_window;

	Atom clipboard_atom;

	Atom property_atom;

	Atom raw_transfer_atom;

	Atom raw_format_list_atom;

	int numClientFormats;

	xfCliprdrFormat clientFormats[20];

	int numServerFormats;

	CLIPRDR_FORMAT* serverFormats;

	int numTargets;

	Atom targets[20];

	int requestedFormatId;

	BYTE* data;

	BYTE* data_raw;

	BOOL data_raw_format;

	UINT32 data_format_id;

	const char* data_format_name;

	int data_length;

	int data_raw_length;

	XSelectionEvent* respond;

	Window owner;

	BOOL sync;

	/* INCR mechanism */

	Atom incr_atom;

	BOOL incr_starts;

	BYTE* incr_data;

	int incr_data_length;

	/* XFixes extension */

	int xfixes_event_base;

	int xfixes_error_base;

	BOOL xfixes_supported;

	/* File clipping */

	BOOL streams_supported;

	BOOL file_formats_registered;

};

static UINT xf_cliprdr_send_client_format_list(xfClipboard* clipboard);

static void xf_cliprdr_check_owner(xfClipboard* clipboard)

{

	Window owner;

	xfContext* xfc = clipboard->xfc;

	if (clipboard->sync)

	{

		owner = XGetSelectionOwner(xfc->display, clipboard->clipboard_atom);

		if (clipboard->owner != owner)

		{

			clipboard->owner = owner;

			xf_cliprdr_send_client_format_list(clipboard);

		}

	}

}

static BOOL xf_cliprdr_is_self_owned(xfClipboard* clipboard)

{

	xfContext* xfc = clipboard->xfc;

	return XGetSelectionOwner(xfc->display, clipboard->clipboard_atom) == xfc->drawable;

}

static void xf_cliprdr_set_raw_transfer_enabled(xfClipboard* clipboard, BOOL enabled)

{

	UINT32 data = enabled;

	xfContext* xfc = clipboard->xfc;

	XChangeProperty(xfc->display, xfc->drawable, clipboard->raw_transfer_atom, XA_INTEGER, 32,

	                PropModeReplace, (BYTE*)&data, 1);

}

static BOOL xf_cliprdr_is_raw_transfer_available(xfClipboard* clipboard)

{

	Atom type;

	int format;

	int result = 0;

	unsigned long length;

	unsigned long bytes_left;

	UINT32* data = NULL;

	UINT32 is_enabled = 0;

	Window owner = None;

	xfContext* xfc = clipboard->xfc;

	owner = XGetSelectionOwner(xfc->display, clipboard->clipboard_atom);

	if (owner != None)

	{

		result =

		    XGetWindowProperty(xfc->display, owner, clipboard->raw_transfer_atom, 0, 4, 0,

		                       XA_INTEGER, &type, &format, &length, &bytes_left, (BYTE**)&data);

	}

	if (data)

	{

		is_enabled = *data;

		XFree(data);

	}

	if ((owner == None) || (owner == xfc->drawable))

		return FALSE;

	if (result != Success)

		return FALSE;

	return is_enabled ? TRUE : FALSE;

}

static BOOL xf_cliprdr_formats_equal(const CLIPRDR_FORMAT* server, const xfCliprdrFormat* client)

{

	if (server->formatName && client->formatName)

	{

		/* The server may be using short format names while we store them in full form. */

		return (0 == strncmp(server->formatName, client->formatName, strlen(server->formatName)));

	}

	if (!server->formatName && !client->formatName)

	{

		return (server->formatId == client->formatId);

	}

	return FALSE;

}

static xfCliprdrFormat* xf_cliprdr_get_client_format_by_id(xfClipboard* clipboard, UINT32 formatId)

{

	int index;

	xfCliprdrFormat* format;

	for (index = 0; index < clipboard->numClientFormats; index++)

	{

		format = &(clipboard->clientFormats[index]);

		if (format->formatId == formatId)

			return format;

	}

	return NULL;

}

static xfCliprdrFormat* xf_cliprdr_get_client_format_by_atom(xfClipboard* clipboard, Atom atom)

{

	int i;

	xfCliprdrFormat* format;

	for (i = 0; i < clipboard->numClientFormats; i++)

	{

		format = &(clipboard->clientFormats[i]);

		if (format->atom == atom)

			return format;

	}

	return NULL;

}

static CLIPRDR_FORMAT* xf_cliprdr_get_server_format_by_atom(xfClipboard* clipboard, Atom atom)

{

	int i, j;

	xfCliprdrFormat* client_format;

	CLIPRDR_FORMAT* server_format;

	for (i = 0; i < clipboard->numClientFormats; i++)

	{

		client_format = &(clipboard->clientFormats[i]);

		if (client_format->atom == atom)

		{

			for (j = 0; j < clipboard->numServerFormats; j++)

			{

				server_format = &(clipboard->serverFormats[j]);

				if (xf_cliprdr_formats_equal(server_format, client_format))

					return server_format;

			}

		}

	}

	return NULL;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT xf_cliprdr_send_data_request(xfClipboard* clipboard, UINT32 formatId)

{

	CLIPRDR_FORMAT_DATA_REQUEST request = { 0 };

	request.requestedFormatId = formatId;

	return clipboard->context->ClientFormatDataRequest(clipboard->context, &request);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT xf_cliprdr_send_data_response(xfClipboard* clipboard, BYTE* data, int size)

{

	CLIPRDR_FORMAT_DATA_RESPONSE response = { 0 };

	response.msgFlags = (data) ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;

	response.dataLen = size;

	response.requestedFormatData = data;

	return clipboard->context->ClientFormatDataResponse(clipboard->context, &response);

}

static wStream* xf_cliprdr_serialize_server_format_list(xfClipboard* clipboard)

{

	UINT32 i;

	UINT32 formatCount;

	wStream* s = NULL;

	/* Typical MS Word format list is about 80 bytes long. */

	if (!(s = Stream_New(NULL, 128)))

	{

		WLog_ERR(TAG, "failed to allocate serialized format list");

		goto error;

	}

	/* If present, the last format is always synthetic CF_RAW. Do not include it. */

	formatCount = (clipboard->numServerFormats > 0) ? clipboard->numServerFormats - 1 : 0;

	Stream_Write_UINT32(s, formatCount);

	for (i = 0; i < formatCount; i++)

	{

		CLIPRDR_FORMAT* format = &clipboard->serverFormats[i];

		size_t name_length = format->formatName ? strlen(format->formatName) : 0;

		if (!Stream_EnsureRemainingCapacity(s, sizeof(UINT32) + name_length + 1))

		{

			WLog_ERR(TAG, "failed to expand serialized format list");

			goto error;

		}

		Stream_Write_UINT32(s, format->formatId);

		if (format->formatName)

			Stream_Write(s, format->formatName, name_length);

		Stream_Write_UINT8(s, '\0');

	}

	Stream_SealLength(s);

	return s;

error:

	Stream_Free(s, TRUE);

	return NULL;

}

static CLIPRDR_FORMAT* xf_cliprdr_parse_server_format_list(BYTE* data, size_t length,

                                                           UINT32* numFormats)

{

	UINT32 i;

	wStream* s = NULL;

	CLIPRDR_FORMAT* formats = NULL;

	if (!(s = Stream_New(data, length)))

	{

		WLog_ERR(TAG, "failed to allocate stream for parsing serialized format list");

		goto error;

	}

	if (Stream_GetRemainingLength(s) < sizeof(UINT32))

	{

		WLog_ERR(TAG, "too short serialized format list");

		goto error;

	}

	Stream_Read_UINT32(s, *numFormats);

	if (*numFormats > MAX_CLIPBOARD_FORMATS)

	{

		WLog_ERR(TAG, "unexpectedly large number of formats: %" PRIu32 "", *numFormats);

		goto error;

	}

	if (!(formats = (CLIPRDR_FORMAT*)calloc(*numFormats, sizeof(CLIPRDR_FORMAT))))

	{

		WLog_ERR(TAG, "failed to allocate format list");

		goto error;

	}

	for (i = 0; i < *numFormats; i++)

	{

		const char* formatName = NULL;

		size_t formatNameLength = 0;

		if (Stream_GetRemainingLength(s) < sizeof(UINT32))

		{

			WLog_ERR(TAG, "unexpected end of serialized format list");

			goto error;

		}

		Stream_Read_UINT32(s, formats[i].formatId);

		formatName = (const char*)Stream_Pointer(s);

		formatNameLength = strnlen(formatName, Stream_GetRemainingLength(s));

		if (formatNameLength == Stream_GetRemainingLength(s))

		{

			WLog_ERR(TAG, "missing terminating null byte, %" PRIuz " bytes left to read",

			         formatNameLength);

			goto error;

		}

		formats[i].formatName = strndup(formatName, formatNameLength);

		Stream_Seek(s, formatNameLength + 1);

	}

	Stream_Free(s, FALSE);

	return formats;

error:

	Stream_Free(s, FALSE);

	free(formats);

	*numFormats = 0;

	return NULL;

}

static void xf_cliprdr_free_formats(CLIPRDR_FORMAT* formats, UINT32 numFormats)

{

	UINT32 i;

	for (i = 0; i < numFormats; i++)

	{

		free(formats[i].formatName);

	}

	free(formats);

}

static CLIPRDR_FORMAT* xf_cliprdr_get_raw_server_formats(xfClipboard* clipboard, UINT32* numFormats)

{

	Atom type = None;

	int format = 0;

	unsigned long length = 0;

	unsigned long remaining;

	BYTE* data = NULL;

	CLIPRDR_FORMAT* formats = NULL;

	xfContext* xfc = clipboard->xfc;

	*numFormats = 0;

	XGetWindowProperty(xfc->display, clipboard->owner, clipboard->raw_format_list_atom, 0, 4096,

	                   False, clipboard->raw_format_list_atom, &type, &format, &length, &remaining,

	                   &data);

	if (data && length > 0 && format == 8 && type == clipboard->raw_format_list_atom)

	{

		formats = xf_cliprdr_parse_server_format_list(data, length, numFormats);

	}

	else

	{

		WLog_ERR(TAG,

		         "failed to retrieve raw format list: data=%p, length=%lu, format=%d, type=%lu "

		         "(expected=%lu)",

		         (void*)data, length, format, (unsigned long)type,

		         (unsigned long)clipboard->raw_format_list_atom);

	}

	if (data)

		XFree(data);

	return formats;

}

static CLIPRDR_FORMAT* xf_cliprdr_get_formats_from_targets(xfClipboard* clipboard,

                                                           UINT32* numFormats)

{

	unsigned long i;

	Atom atom;

	BYTE* data = NULL;

	int format_property;

	unsigned long length;

	unsigned long bytes_left;

	xfCliprdrFormat* format = NULL;

	CLIPRDR_FORMAT* formats = NULL;

	xfContext* xfc = clipboard->xfc;

	*numFormats = 0;

	XGetWindowProperty(xfc->display, xfc->drawable, clipboard->property_atom, 0, 200, 0, XA_ATOM,

	                   &atom, &format_property, &length, &bytes_left, &data);

	if (length > 0)

	{

		if (!data)

		{

			WLog_ERR(TAG, "XGetWindowProperty set length = %lu but data is NULL", length);

			goto out;

		}

		if (!(formats = (CLIPRDR_FORMAT*)calloc(length, sizeof(CLIPRDR_FORMAT))))

		{

			WLog_ERR(TAG, "failed to allocate %lu CLIPRDR_FORMAT structs", length);

			goto out;

		}

	}

	for (i = 0; i < length; i++)

	{

		atom = ((Atom*)data)[i];

		format = xf_cliprdr_get_client_format_by_atom(clipboard, atom);

		if (format)

		{

			formats[*numFormats].formatId = format->formatId;

			formats[*numFormats].formatName = _strdup(format->formatName);

			*numFormats += 1;

		}

	}

out:

	if (data)

		XFree(data);

	return formats;

}

static CLIPRDR_FORMAT* xf_cliprdr_get_client_formats(xfClipboard* clipboard, UINT32* numFormats)

{

	CLIPRDR_FORMAT* formats = NULL;

	*numFormats = 0;

	if (xf_cliprdr_is_raw_transfer_available(clipboard))

	{

		formats = xf_cliprdr_get_raw_server_formats(clipboard, numFormats);

	}

	if (*numFormats == 0)

	{

		xf_cliprdr_free_formats(formats, *numFormats);

		formats = xf_cliprdr_get_formats_from_targets(clipboard, numFormats);

	}

	return formats;

}

static void xf_cliprdr_provide_server_format_list(xfClipboard* clipboard)

{

	wStream* formats = NULL;

	xfContext* xfc = clipboard->xfc;

	formats = xf_cliprdr_serialize_server_format_list(clipboard);

	if (formats)

	{

		XChangeProperty(xfc->display, xfc->drawable, clipboard->raw_format_list_atom,

		                clipboard->raw_format_list_atom, 8, PropModeReplace, Stream_Buffer(formats),

		                Stream_Length(formats));

	}

	else

	{

		XDeleteProperty(xfc->display, xfc->drawable, clipboard->raw_format_list_atom);

	}

	Stream_Free(formats, TRUE);

}

static void xf_cliprdr_get_requested_targets(xfClipboard* clipboard)

{

	UINT32 numFormats = 0;

	CLIPRDR_FORMAT* formats = NULL;

	CLIPRDR_FORMAT_LIST formatList = { 0 };

	formats = xf_cliprdr_get_client_formats(clipboard, &numFormats);

	formatList.msgFlags = CB_RESPONSE_OK;

	formatList.numFormats = numFormats;

	formatList.formats = formats;

	formatList.msgType = CB_FORMAT_LIST;

	clipboard->context->ClientFormatList(clipboard->context, &formatList);

	xf_cliprdr_free_formats(formats, numFormats);

}

static void xf_cliprdr_process_requested_data(xfClipboard* clipboard, BOOL hasData, BYTE* data,

                                              int size)

{

	BOOL bSuccess;

	UINT32 SrcSize;

	UINT32 DstSize;

	UINT32 srcFormatId;

	UINT32 dstFormatId;

	BYTE* pDstData = NULL;

	xfCliprdrFormat* format;

	if (clipboard->incr_starts && hasData)

		return;

	format = xf_cliprdr_get_client_format_by_id(clipboard, clipboard->requestedFormatId);

	if (!hasData || !data || !format)

	{

		xf_cliprdr_send_data_response(clipboard, NULL, 0);

		return;

	}

	srcFormatId = 0;

	switch (format->formatId)

	{

		case CF_RAW:

			srcFormatId = CF_RAW;

			break;

		case CF_TEXT:

		case CF_OEMTEXT:

		case CF_UNICODETEXT:

			size = strlen((char*)data) + 1;

			srcFormatId = ClipboardGetFormatId(clipboard->system, "UTF8_STRING");

			break;

		case CF_DIB:

			srcFormatId = ClipboardGetFormatId(clipboard->system, "image/bmp");

			break;

		case CB_FORMAT_HTML:

			srcFormatId = ClipboardGetFormatId(clipboard->system, "text/html");

			break;

		case CB_FORMAT_TEXTURILIST:

			srcFormatId = ClipboardGetFormatId(clipboard->system, "text/uri-list");

			break;

	}

	SrcSize = (UINT32)size;

	bSuccess = ClipboardSetData(clipboard->system, srcFormatId, data, SrcSize);

	if (format->formatName)

		dstFormatId = ClipboardGetFormatId(clipboard->system, format->formatName);

	else

		dstFormatId = format->formatId;

	if (bSuccess)

	{

		DstSize = 0;

		pDstData = (BYTE*)ClipboardGetData(clipboard->system, dstFormatId, &DstSize);

	}

	if (!pDstData)

	{

		xf_cliprdr_send_data_response(clipboard, NULL, 0);

		return;

	}

	/*

	 * File lists require a bit of postprocessing to convert them from WinPR's FILDESCRIPTOR

	 * format to CLIPRDR_FILELIST expected by the server.

	 *

	 * We check for "FileGroupDescriptorW" format being registered (i.e., nonzero) in order

	 * to not process CF_RAW as a file list in case WinPR does not support file transfers.

	 */

	if (dstFormatId &&

	    (dstFormatId == ClipboardGetFormatId(clipboard->system, "FileGroupDescriptorW")))

	{

		UINT error = NO_ERROR;

		FILEDESCRIPTOR* file_array = (FILEDESCRIPTOR*)pDstData;

		UINT32 file_count = DstSize / sizeof(FILEDESCRIPTOR);

		pDstData = NULL;

		DstSize = 0;

		error = cliprdr_serialize_file_list(file_array, file_count, &pDstData, &DstSize);

		if (error)

			WLog_ERR(TAG, "failed to serialize CLIPRDR_FILELIST: 0x%08X", error);

		free(file_array);

	}

	xf_cliprdr_send_data_response(clipboard, pDstData, (int)DstSize);

	free(pDstData);

}

static BOOL xf_cliprdr_get_requested_data(xfClipboard* clipboard, Atom target)

{

	Atom type;

	BYTE* data = NULL;

	BOOL has_data = FALSE;

	int format_property;

	unsigned long dummy;

	unsigned long length;

	unsigned long bytes_left;

	xfCliprdrFormat* format;

	xfContext* xfc = clipboard->xfc;

	format = xf_cliprdr_get_client_format_by_id(clipboard, clipboard->requestedFormatId);

	if (!format || (format->atom != target))

	{

		xf_cliprdr_send_data_response(clipboard, NULL, 0);

		return FALSE;

	}

	XGetWindowProperty(xfc->display, xfc->drawable, clipboard->property_atom, 0, 0, 0, target,

	                   &type, &format_property, &length, &bytes_left, &data);

	if (data)

	{

		XFree(data);

		data = NULL;

	}

	if (bytes_left <= 0 && !clipboard->incr_starts)

	{

	}

	else if (type == clipboard->incr_atom)

	{

		clipboard->incr_starts = TRUE;

		if (clipboard->incr_data)

		{

			free(clipboard->incr_data);

			clipboard->incr_data = NULL;

		}

		clipboard->incr_data_length = 0;

		has_data = TRUE; /* data will be followed in PropertyNotify event */

	}

	else

	{

		if (bytes_left <= 0)

		{

			/* INCR finish */

			data = clipboard->incr_data;

			clipboard->incr_data = NULL;

			bytes_left = clipboard->incr_data_length;

			clipboard->incr_data_length = 0;

			clipboard->incr_starts = 0;

			has_data = TRUE;

		}

		else if (XGetWindowProperty(xfc->display, xfc->drawable, clipboard->property_atom, 0,

		                            bytes_left, 0, target, &type, &format_property, &length, &dummy,

		                            &data) == Success)

		{

			if (clipboard->incr_starts)

			{

				BYTE* new_data;

				bytes_left = length * format_property / 8;

				new_data =

				    (BYTE*)realloc(clipboard->incr_data, clipboard->incr_data_length + bytes_left);

				if (!new_data)

					return FALSE;

				clipboard->incr_data = new_data;

				CopyMemory(clipboard->incr_data + clipboard->incr_data_length, data, bytes_left);

				clipboard->incr_data_length += bytes_left;

				XFree(data);

				data = NULL;

			}

			has_data = TRUE;

		}

		else

		{

		}

	}

	XDeleteProperty(xfc->display, xfc->drawable, clipboard->property_atom);

	xf_cliprdr_process_requested_data(clipboard, has_data, data, (int)bytes_left);

	if (data)

		XFree(data);

	return TRUE;

}

static void xf_cliprdr_append_target(xfClipboard* clipboard, Atom target)

{

	int i;

	if (clipboard->numTargets < 0)

		return;

	if ((size_t)clipboard->numTargets >= ARRAYSIZE(clipboard->targets))

		return;

	for (i = 0; i < clipboard->numTargets; i++)

	{

		if (clipboard->targets[i] == target)

			return;

	}

	clipboard->targets[clipboard->numTargets++] = target;

}

static void xf_cliprdr_provide_targets(xfClipboard* clipboard, const XSelectionEvent* respond)

{

	xfContext* xfc = clipboard->xfc;

	if (respond->property != None)

	{

		XChangeProperty(xfc->display, respond->requestor, respond->property, XA_ATOM, 32,

		                PropModeReplace, (BYTE*)clipboard->targets, clipboard->numTargets);

	}

}

static void xf_cliprdr_provide_data(xfClipboard* clipboard, const XSelectionEvent* respond,

                                    const BYTE* data, UINT32 size)

{

	xfContext* xfc = clipboard->xfc;

	if (respond->property != None)

	{

		XChangeProperty(xfc->display, respond->requestor, respond->property, respond->target, 8,

		                PropModeReplace, data, size);

	}

}

static BOOL xf_cliprdr_process_selection_notify(xfClipboard* clipboard,

                                                const XSelectionEvent* xevent)

{

	if (xevent->target == clipboard->targets[1])

	{

		if (xevent->property == None)

		{

			xf_cliprdr_send_client_format_list(clipboard);

		}

		else

		{

			xf_cliprdr_get_requested_targets(clipboard);

		}

		return TRUE;

	}

	else

	{

		return xf_cliprdr_get_requested_data(clipboard, xevent->target);

	}

}

static void xf_cliprdr_clear_cached_data(xfClipboard* clipboard)

{

	if (clipboard->data)

	{

		free(clipboard->data);

		clipboard->data = NULL;

	}

	clipboard->data_length = 0;

	if (clipboard->data_raw)

	{

		free(clipboard->data_raw);

		clipboard->data_raw = NULL;

	}

	clipboard->data_raw_length = 0;

}

static BOOL xf_cliprdr_process_selection_request(xfClipboard* clipboard,

                                                 const XSelectionRequestEvent* xevent)

{

	int fmt;

	Atom type;

	UINT32 formatId;

	const char* formatName;

	XSelectionEvent* respond;

	BYTE* data = NULL;

	BOOL delayRespond;

	BOOL rawTransfer;

	BOOL matchingFormat;

	unsigned long length;

	unsigned long bytes_left;

	CLIPRDR_FORMAT* format;

	xfContext* xfc = clipboard->xfc;

	if (xevent->owner != xfc->drawable)

		return FALSE;

	delayRespond = FALSE;

	if (!(respond = (XSelectionEvent*)calloc(1, sizeof(XSelectionEvent))))

	{

		WLog_ERR(TAG, "failed to allocate XEvent data");

		return FALSE;

	}

	respond->property = None;

	respond->type = SelectionNotify;

	respond->display = xevent->display;

	respond->requestor = xevent->requestor;

	respond->selection = xevent->selection;

	respond->target = xevent->target;

	respond->time = xevent->time;

	if (xevent->target == clipboard->targets[0]) /* TIMESTAMP */

	{

		/* TODO */

	}

	else if (xevent->target == clipboard->targets[1]) /* TARGETS */

	{

		/* Someone else requests our available formats */

		respond->property = xevent->property;

		xf_cliprdr_provide_targets(clipboard, respond);

	}

	else

	{

		format = xf_cliprdr_get_server_format_by_atom(clipboard, xevent->target);

		if (format && (xevent->requestor != xfc->drawable))

		{

			formatId = format->formatId;

			formatName = format->formatName;

			rawTransfer = FALSE;

			if (formatId == CF_RAW)

			{

				if (XGetWindowProperty(xfc->display, xevent->requestor, clipboard->property_atom, 0,

				                       4, 0, XA_INTEGER, &type, &fmt, &length, &bytes_left,

				                       &data) != Success)

				{

				}

				if (data)

				{

					rawTransfer = TRUE;