FreeRDP/channels/cliprdr/cliprdr_main.c

277 lines
7.1 KiB
C
Raw Normal View History

2011-07-12 13:06:14 +04:00
/**
* FreeRDP: A Remote Desktop Protocol client.
* Clipboard Virtual Channel
*
* Copyright 2009-2011 Jay Sorg
* Copyright 2010-2011 Vic Lee
*
* 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 <stdlib.h>
#include <string.h>
#include <freerdp/types.h>
#include <freerdp/constants.h>
2011-07-12 13:06:14 +04:00
#include <freerdp/utils/memory.h>
#include <freerdp/utils/unicode.h>
2011-07-12 13:06:14 +04:00
#include <freerdp/utils/svc_plugin.h>
2011-08-11 07:07:03 +04:00
#include <freerdp/plugins/cliprdr.h>
2011-07-12 13:06:14 +04:00
#include "cliprdr_constants.h"
#include "cliprdr_main.h"
2011-07-12 19:06:39 +04:00
#include "cliprdr_format.h"
2011-07-12 13:06:14 +04:00
static const char* const CB_MSG_TYPE_STRINGS[] =
{
"",
"CB_MONITOR_READY",
"CB_FORMAT_LIST",
"CB_FORMAT_LIST_RESPONSE",
"CB_FORMAT_DATA_REQUEST",
"CB_FORMAT_DATA_RESPONSE",
"CB_TEMP_DIRECTORY",
"CB_CLIP_CAPS",
"CB_FILECONTENTS_REQUEST",
"CB_FILECONTENTS_RESPONSE",
"CB_LOCK_CLIPDATA"
"CB_UNLOCK_CLIPDATA"
};
2011-07-12 13:06:14 +04:00
STREAM* cliprdr_packet_new(uint16 msgType, uint16 msgFlags, uint32 dataLen)
{
2011-09-23 07:37:17 +04:00
STREAM* s;
2011-07-12 13:06:14 +04:00
2011-09-23 07:37:17 +04:00
s = stream_new(dataLen + 8);
stream_write_uint16(s, msgType);
stream_write_uint16(s, msgFlags);
2011-07-12 13:06:14 +04:00
/* Write actual length after the entire packet has been constructed. */
2011-09-23 07:37:17 +04:00
stream_seek(s, 4);
2011-07-12 13:06:14 +04:00
2011-09-23 07:37:17 +04:00
return s;
2011-07-12 13:06:14 +04:00
}
2011-09-23 07:37:17 +04:00
void cliprdr_packet_send(cliprdrPlugin* cliprdr, STREAM* s)
2011-07-12 13:06:14 +04:00
{
int pos;
uint32 dataLen;
2011-09-23 07:37:17 +04:00
pos = stream_get_pos(s);
2011-07-12 13:06:14 +04:00
dataLen = pos - 8;
2011-09-23 07:37:17 +04:00
stream_set_pos(s, 4);
stream_write_uint32(s, dataLen);
stream_set_pos(s, pos);
2011-07-12 13:06:14 +04:00
svc_plugin_send((rdpSvcPlugin*) cliprdr, s);
2011-07-12 13:06:14 +04:00
}
static void cliprdr_process_connect(rdpSvcPlugin* plugin)
{
DEBUG_CLIPRDR("connecting");
((cliprdrPlugin*) plugin)->uniconv = freerdp_uniconv_new();
}
void cliprdr_print_general_capability_flags(uint32 flags)
{
printf("generalFlags (0x%08X) {\n", flags);
if (flags & CB_USE_LONG_FORMAT_NAMES)
printf("\tCB_USE_LONG_FORMAT_NAMES\n");
if (flags & CB_STREAM_FILECLIP_ENABLED)
printf("\tCB_STREAM_FILECLIP_ENABLED\n");
if (flags & CB_FILECLIP_NO_FILE_PATHS)
printf("\tCB_FILECLIP_NO_FILE_PATHS\n");
if (flags & CB_CAN_LOCK_CLIPDATA)
printf("\tCB_CAN_LOCK_CLIPDATA\n");
printf("}\n");
}
static void cliprdr_process_general_capability(cliprdrPlugin* cliprdr, STREAM* s)
{
uint32 version;
uint32 generalFlags;
stream_read_uint32(s, version); /* version (4 bytes) */
stream_read_uint32(s, generalFlags); /* generalFlags (4 bytes) */
DEBUG_CLIPRDR("Version: %d", version);
#ifdef WITH_DEBUG_CLIPRDR
cliprdr_print_general_capability_flags(generalFlags);
#endif
if (generalFlags & CB_USE_LONG_FORMAT_NAMES)
cliprdr->use_long_format_names = true;
if (generalFlags & CB_STREAM_FILECLIP_ENABLED)
cliprdr->stream_fileclip_enabled = true;
if (generalFlags & CB_FILECLIP_NO_FILE_PATHS)
cliprdr->fileclip_no_file_paths = true;
if (generalFlags & CB_CAN_LOCK_CLIPDATA)
cliprdr->can_lock_clipdata = true;
cliprdr->received_caps = true;
2011-07-12 13:06:14 +04:00
}
static void cliprdr_process_clip_caps(cliprdrPlugin* cliprdr, STREAM* s, uint16 length, uint16 flags)
2011-07-12 13:06:14 +04:00
{
int i;
uint16 lengthCapability;
2011-07-12 13:06:14 +04:00
uint16 cCapabilitiesSets;
uint16 capabilitySetType;
stream_read_uint16(s, cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
stream_seek_uint16(s); /* pad1 (2 bytes) */
2011-07-12 13:06:14 +04:00
DEBUG_CLIPRDR("cCapabilitiesSets %d", cCapabilitiesSets);
for (i = 0; i < cCapabilitiesSets; i++)
{
stream_read_uint16(s, capabilitySetType); /* capabilitySetType (2 bytes) */
stream_read_uint16(s, lengthCapability); /* lengthCapability (2 bytes) */
switch (capabilitySetType)
{
case CB_CAPSTYPE_GENERAL:
cliprdr_process_general_capability(cliprdr, s);
break;
default:
DEBUG_WARN("unknown cliprdr capability set: %d", capabilitySetType);
break;
}
}
2011-07-12 13:06:14 +04:00
}
static void cliprdr_send_clip_caps(cliprdrPlugin* cliprdr)
{
2011-09-23 07:37:17 +04:00
STREAM* s;
uint32 flags;
2011-07-12 13:06:14 +04:00
2011-09-23 07:37:17 +04:00
s = cliprdr_packet_new(CB_CLIP_CAPS, 0, 4 + CB_CAPSTYPE_GENERAL_LEN);
2011-07-12 13:06:14 +04:00
DEBUG_CLIPRDR("Sending Capabilities");
flags = CB_USE_LONG_FORMAT_NAMES;
2011-09-23 07:37:17 +04:00
stream_write_uint16(s, 1); /* cCapabilitiesSets */
stream_write_uint16(s, 0); /* pad1 */
stream_write_uint16(s, CB_CAPSTYPE_GENERAL); /* capabilitySetType */
stream_write_uint16(s, CB_CAPSTYPE_GENERAL_LEN); /* lengthCapability */
stream_write_uint32(s, CB_CAPS_VERSION_2); /* version */
stream_write_uint32(s, flags); /* generalFlags */
2011-07-12 13:06:14 +04:00
2011-09-23 07:37:17 +04:00
cliprdr_packet_send(cliprdr, s);
2011-07-12 13:06:14 +04:00
}
static void cliprdr_process_monitor_ready(cliprdrPlugin* cliprdr, STREAM* s, uint16 length, uint16 flags)
2011-07-12 13:06:14 +04:00
{
2011-08-18 01:28:26 +04:00
RDP_EVENT* event;
2011-07-12 18:09:56 +04:00
if (cliprdr->received_caps)
cliprdr_send_clip_caps(cliprdr);
2011-07-12 18:09:56 +04:00
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_MONITOR_READY, NULL, NULL);
svc_plugin_send_event((rdpSvcPlugin*) cliprdr, event);
2011-07-12 13:06:14 +04:00
}
2011-09-23 07:37:17 +04:00
static void cliprdr_process_receive(rdpSvcPlugin* plugin, STREAM* s)
2011-07-12 13:06:14 +04:00
{
uint16 msgType;
uint16 msgFlags;
uint32 dataLen;
cliprdrPlugin* cliprdr = (cliprdrPlugin*) plugin;
2011-07-12 13:06:14 +04:00
2011-09-23 07:37:17 +04:00
stream_read_uint16(s, msgType);
stream_read_uint16(s, msgFlags);
stream_read_uint32(s, dataLen);
2011-07-12 13:06:14 +04:00
DEBUG_CLIPRDR("msgType: %s (%d), msgFlags: %d dataLen: %d",
CB_MSG_TYPE_STRINGS[msgType], msgType, msgFlags, dataLen);
2011-07-12 13:06:14 +04:00
switch (msgType)
{
case CB_CLIP_CAPS:
cliprdr_process_clip_caps(cliprdr, s, dataLen, msgFlags);
2011-07-12 13:06:14 +04:00
break;
case CB_MONITOR_READY:
cliprdr_process_monitor_ready(cliprdr, s, dataLen, msgFlags);
2011-07-12 13:06:14 +04:00
break;
2011-07-12 19:53:54 +04:00
case CB_FORMAT_LIST:
cliprdr_process_format_list(cliprdr, s, dataLen, msgFlags);
2011-07-12 19:53:54 +04:00
break;
case CB_FORMAT_LIST_RESPONSE:
cliprdr_process_format_list_response(cliprdr, s, dataLen, msgFlags);
break;
case CB_FORMAT_DATA_REQUEST:
cliprdr_process_format_data_request(cliprdr, s, dataLen, msgFlags);
break;
case CB_FORMAT_DATA_RESPONSE:
cliprdr_process_format_data_response(cliprdr, s, dataLen, msgFlags);
break;
2011-07-12 13:06:14 +04:00
default:
DEBUG_WARN("unknown msgType %d", msgType);
break;
}
2011-09-23 07:37:17 +04:00
stream_free(s);
2011-07-12 13:06:14 +04:00
}
2011-08-18 01:28:26 +04:00
static void cliprdr_process_event(rdpSvcPlugin* plugin, RDP_EVENT* event)
2011-07-12 13:06:14 +04:00
{
2011-07-12 19:06:39 +04:00
switch (event->event_type)
{
2011-08-18 01:28:26 +04:00
case RDP_EVENT_TYPE_CB_FORMAT_LIST:
cliprdr_process_format_list_event((cliprdrPlugin*) plugin, (RDP_CB_FORMAT_LIST_EVENT*) event);
2011-07-12 19:06:39 +04:00
break;
2011-08-18 01:28:26 +04:00
case RDP_EVENT_TYPE_CB_DATA_REQUEST:
cliprdr_process_format_data_request_event((cliprdrPlugin*) plugin, (RDP_CB_DATA_REQUEST_EVENT*) event);
break;
2011-08-18 01:28:26 +04:00
case RDP_EVENT_TYPE_CB_DATA_RESPONSE:
cliprdr_process_format_data_response_event((cliprdrPlugin*) plugin, (RDP_CB_DATA_RESPONSE_EVENT*) event);
break;
2011-07-12 19:06:39 +04:00
default:
DEBUG_WARN("unknown event type %d", event->event_type);
break;
}
2011-07-12 19:06:39 +04:00
freerdp_event_free(event);
2011-07-12 13:06:14 +04:00
}
static void cliprdr_process_terminate(rdpSvcPlugin* plugin)
{
cliprdrPlugin* cliprdr_plugin = (cliprdrPlugin*) plugin;
if (cliprdr_plugin->uniconv != NULL)
freerdp_uniconv_free(cliprdr_plugin->uniconv);
2011-07-12 13:06:14 +04:00
xfree(plugin);
}
DEFINE_SVC_PLUGIN(cliprdr, "cliprdr",
CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL)