static BOOL wl_context_new(freerdp* instance, rdpContext* context)
{
if (!(context->channels = freerdp_channels_new()))
return FALSE;
return TRUE;
}
static void remmina_rdp_init(RemminaProtocolWidget* gp)
{
freerdp* instance;
rfContext* rfi;
instance = freerdp_new();
instance->PreConnect = remmina_rdp_pre_connect;
instance->PostConnect = remmina_rdp_post_connect;
instance->Authenticate = remmina_rdp_authenticate;
instance->VerifyCertificate = remmina_rdp_verify_certificate;
instance->VerifyChangedCertificate = remmina_rdp_verify_changed_certificate;
instance->ReceiveChannelData = remmina_rdp_receive_channel_data;
instance->ContextSize = sizeof(rfContext);
freerdp_context_new(instance);
rfi = (rfContext*) instance->context;
g_object_set_data_full(G_OBJECT(gp), "plugin-data", rfi, free);
rfi->protocol_widget = gp;
rfi->instance = instance;
rfi->settings = instance->settings;
rfi->channels = freerdp_channels_new();
pthread_mutex_init(&rfi->mutex, NULL);
rfi->gmutex = g_mutex_new();
rfi->gcond = g_cond_new();
remmina_rdp_event_init(gp);
}
void test_channels(void)
{
rdpChannels* chan_man;
rdpSettings settings = { 0 };
freerdp instance = { 0 };
RDP_EVENT* event;
settings.hostname = "testhost";
instance.settings = &settings;
instance.SendChannelData = test_rdp_channel_data;
chan_man = freerdp_channels_new();
freerdp_channels_load_plugin(chan_man, &settings, "../channels/rdpdbg/rdpdbg.so", NULL);
freerdp_channels_pre_connect(chan_man, &instance);
freerdp_channels_post_connect(chan_man, &instance);
freerdp_channels_data(&instance, 0, "testdata", 8, CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, 8);
freerdp_channels_data(&instance, 0, "testdata1", 9, CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, 9);
freerdp_channels_data(&instance, 0, "testdata11", 10, CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, 10);
freerdp_channels_data(&instance, 0, "testdata111", 11, CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, 11);
event = freerdp_event_new(RDP_EVENT_CLASS_DEBUG, 0, NULL, NULL);
freerdp_channels_send_event(chan_man, event);
while ((event = freerdp_channels_pop_event(chan_man)) == NULL)
{
freerdp_channels_check_fds(chan_man, &instance);
}
printf("responded event_type %d\n", event->event_type);
freerdp_event_free(event);
freerdp_channels_close(chan_man, &instance);
freerdp_channels_free(chan_man);
}
void test_drdynvc(void)
{
rdpChannels* chan_man;
rdpSettings settings = { 0 };
freerdp instance = { 0 };
settings.Hostname = "testhost";
instance.settings = &settings;
instance.SendChannelData = test_rdp_channel_data;
chan_man = freerdp_channels_new();
freerdp_channels_load_plugin(chan_man, &settings, "../channels/drdynvc/drdynvc.so", NULL);
freerdp_channels_pre_connect(chan_man, &instance);
freerdp_channels_post_connect(chan_man, &instance);
/* server sends capability request PDU */
freerdp_channels_data(&instance, 0, (char*)test_capability_request_data, sizeof(test_capability_request_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_capability_request_data) - 1);
/* drdynvc sends capability response PDU to server */
data_received = 0;
while (!data_received)
{
freerdp_channels_check_fds(chan_man, &instance);
}
freerdp_channels_close(chan_man, &instance);
freerdp_channels_free(chan_man);
}
static BOOL android_context_new(freerdp* instance, rdpContext* context)
{
if (!(context->channels = freerdp_channels_new()))
return FALSE;
if (!android_event_queue_init(instance))
{
freerdp_channels_free(context->channels);
return FALSE;
}
return TRUE;
}
void wf_context_new(freerdp* instance, rdpContext* context)
{
wfInfo* wfi;
context->channels = freerdp_channels_new();
wfi = (wfInfo*) malloc(sizeof(wfInfo));
ZeroMemory(wfi, sizeof(wfInfo));
((wfContext*) context)->wfi = wfi;
wfi->instance = instance;
}
int wfreerdp_client_new(freerdp* instance, rdpContext* context)
{
wfContext* wfc = (wfContext*) context;
wfreerdp_client_global_init();
instance->PreConnect = wf_pre_connect;
instance->PostConnect = wf_post_connect;
instance->Authenticate = wf_authenticate;
instance->VerifyCertificate = wf_verify_certificate;
instance->ReceiveChannelData = wf_receive_channel_data;
wfc->instance = instance;
context->channels = freerdp_channels_new();
return 0;
}
BOOL wfreerdp_client_new(freerdp* instance, rdpContext* context)
{
wfContext* wfc = (wfContext*) context;
if (!(wfreerdp_client_global_init()))
return FALSE;
if (!(context->channels = freerdp_channels_new()))
return FALSE;
instance->PreConnect = wf_pre_connect;
instance->PostConnect = wf_post_connect;
instance->Authenticate = wf_authenticate;
instance->VerifyCertificate = wf_verify_certificate;
wfc->instance = instance;
wfc->settings = instance->settings;
return TRUE;
}
//-----------------------------------------------------------------------------
void test_rail_plugin(void)
{
thread_param param;
pthread_t thread;
rdpChannels* chan_man;
rdpSettings settings = { 0 };
freerdp s_inst = { 0 };
freerdp* inst = &s_inst;
size_t sn = 0;
size_t en = 0;
STREAM* ss = NULL;
RAIL_EVENT* ee = NULL;
printf("\n");
settings.hostname = "testhost";
inst->settings = &settings;
inst->SendChannelData = emulate_client_send_channel_data;
chan_man = freerdp_channels_new();
freerdp_channels_load_plugin(chan_man, &settings, "../channels/rail/rail.so", NULL);
freerdp_channels_pre_connect(chan_man, inst);
freerdp_channels_post_connect(chan_man, inst);
memset(¶m, 0, sizeof(param));
param.chan_man = chan_man;
param.instance = inst;
param.th_count = 0;
param.th_to_finish = 0;
global_thread_params = ¶m;
pthread_create(&thread, 0, thread_func, ¶m);
// 1. Emulate server handshake binary
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_handshake);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_exec_result_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_sysparam1_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_sysparam2_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_localmovesize_start_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_localmovesize_stop_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_minmaxinfo_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_langbar_pdu);
EMULATE_SERVER_SEND_CHANNEL_DATA(inst, server_app_get_resp_pdu);
// 2. Send UI events
param.out_rail_orders.sysparam.params = 0;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_HIGH_CONTRAST;
param.out_rail_orders.sysparam.highContrast.flags = 0x7e;
param.out_rail_orders.sysparam.highContrast.colorScheme.length = 0;
param.out_rail_orders.sysparam.highContrast.colorScheme.string = NULL;
param.out_rail_orders.sysparam.params |= SPI_MASK_TASKBAR_POS;
param.out_rail_orders.sysparam.taskbarPos.left = 0;
param.out_rail_orders.sysparam.taskbarPos.top = 0x039a;
param.out_rail_orders.sysparam.taskbarPos.right = 0x0690;
param.out_rail_orders.sysparam.taskbarPos.bottom = 0x03c2;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_MOUSE_BUTTON_SWAP;
param.out_rail_orders.sysparam.mouseButtonSwap = False;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_KEYBOARD_PREF;
param.out_rail_orders.sysparam.keyboardPref = False;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_DRAG_FULL_WINDOWS;
param.out_rail_orders.sysparam.dragFullWindows = True;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_KEYBOARD_CUES;
param.out_rail_orders.sysparam.keyboardCues = False;
param.out_rail_orders.sysparam.params |= SPI_MASK_SET_WORK_AREA;
param.out_rail_orders.sysparam.workArea.left = 0;
param.out_rail_orders.sysparam.workArea.top = 0;
param.out_rail_orders.sysparam.workArea.right = 0x0690;
param.out_rail_orders.sysparam.workArea.bottom = 0x039a;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_SET_SYSPARAMS,
¶m.out_rail_orders.sysparam);
param.plugin_data.size = sizeof(RDP_PLUGIN_DATA);
param.plugin_data.data[0] = "||iexplore";
param.plugin_data.data[1] = "f:\\windows\\system32";
param.plugin_data.data[2] = "www.bing.com";
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_EXEC_REMOTE_APP,
¶m.plugin_data);
param.out_rail_orders.activate.enabled = True;
param.out_rail_orders.activate.windowId = 0x0007008e;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_ACTIVATE,
¶m.out_rail_orders.activate);
param.out_rail_orders.syscommand.windowId = 0x00020052;
param.out_rail_orders.syscommand.command = 0xf020;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_SYSCOMMAND,
¶m.out_rail_orders.syscommand);
param.out_rail_orders.notify_event.windowId = 0x000201aa;
param.out_rail_orders.notify_event.notifyIconId = 0x02;
param.out_rail_orders.notify_event.message = 0x0204;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_NOTIFY_EVENT,
¶m.out_rail_orders.notify_event);
param.out_rail_orders.window_move.windowId = 0x00020020;
param.out_rail_orders.window_move.left = 0x0309;
param.out_rail_orders.window_move.top = 0x0100;
param.out_rail_orders.window_move.right = 0x05db;
param.out_rail_orders.window_move.bottom = 0x0188;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE,
¶m.out_rail_orders.window_move);
param.out_rail_orders.sysmenu.windowId = 0x00090122;
param.out_rail_orders.sysmenu.left = 0xffa4; // TODO: possible negative values?
param.out_rail_orders.sysmenu.top = 0x024a;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_SYSMENU,
¶m.out_rail_orders.sysmenu);
param.out_rail_orders.langbar_info.languageBarStatus = 0x00000001;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_LANGBARINFO,
¶m.out_rail_orders.langbar_info);
param.out_rail_orders.get_appid_req.windowId = 0x00020052;
send_ui_event2plugin(chan_man, RDP_EVENT_TYPE_RAIL_CLIENT_APPID_REQ,
¶m.out_rail_orders.get_appid_req);
// Waiting for possible events or data
sleep(1);
// Finishing thread and wait for it
param.th_to_finish = 1;
while (param.th_count > 0)
{
usleep(1000);
}
// We need to collected all events and data dumps and then to.
// create CU_ASSERT series here!
sn = param.in_streams_number;
en = param.in_events_number;
ss = ¶m.in_streams[0];
ee = ¶m.in_events[0];
CU_ASSERT(sn > 0 && STREAM_EQUAL_TO_DUMP(&ss[ 0], client_handshake));
CU_ASSERT(sn > 1 && STREAM_EQUAL_TO_DUMP(&ss[ 1], client_info_pdu));
CU_ASSERT(sn > 2 && STREAM_EQUAL_TO_DUMP(&ss[ 2], client_sysparam_highcontrast_pdu));
CU_ASSERT(sn > 3 && STREAM_EQUAL_TO_DUMP(&ss[ 3], client_sysparam_taskbarpos_pdu));
CU_ASSERT(sn > 4 && STREAM_EQUAL_TO_DUMP(&ss[ 4], client_sysparam_mousebuttonswap_pdu));
CU_ASSERT(sn > 5 && STREAM_EQUAL_TO_DUMP(&ss[ 5], client_sysparam_keyboardpref_pdu));
CU_ASSERT(sn > 6 && STREAM_EQUAL_TO_DUMP(&ss[ 6], client_sysparam_dragfullwindow_pdu));
CU_ASSERT(sn > 7 && STREAM_EQUAL_TO_DUMP(&ss[ 7], client_sysparam_keyboardcues_pdu));
CU_ASSERT(sn > 8 && STREAM_EQUAL_TO_DUMP(&ss[ 8], client_sysparam_setworkarea_pdu));
CU_ASSERT(sn > 9 && STREAM_EQUAL_TO_DUMP(&ss[ 9], client_execute_pdu));
CU_ASSERT(sn >10 && STREAM_EQUAL_TO_DUMP(&ss[10], client_activate_pdu));
CU_ASSERT(sn >11 && STREAM_EQUAL_TO_DUMP(&ss[11], client_syscommand_pdu));
CU_ASSERT(sn >12 && STREAM_EQUAL_TO_DUMP(&ss[12], client_notify_pdu));
CU_ASSERT(sn >13 && STREAM_EQUAL_TO_DUMP(&ss[13], client_windowmove_pdu));
CU_ASSERT(sn >14 && STREAM_EQUAL_TO_DUMP(&ss[14], client_system_menu_pdu));
CU_ASSERT(sn >15 && STREAM_EQUAL_TO_DUMP(&ss[15], client_langbar_pdu));
CU_ASSERT(sn >16 && STREAM_EQUAL_TO_DUMP(&ss[16], client_get_app_id_req_pdu));
CU_ASSERT(en > 0 && ee[ 0].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS);
CU_ASSERT(en > 1 &&
ee[ 1].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS &&
ee[ 1].order_info.exec_result.flags == 0x08 &&
ee[ 1].order_info.exec_result.execResult == 0x03 &&
UNICODE_STRING_EQUAL_TO_DUMP(
&ee[ 1].order_info.exec_result.exeOrFile,
server_exec_result_exe_or_file)
);
CU_ASSERT(en > 2 &&
ee[ 2].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM &&
ee[ 2].order_info.sysparam.setScreenSaveSecure == False
);
CU_ASSERT(en > 3 &&
ee[ 3].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM &&
ee[ 3].order_info.sysparam.setScreenSaveActive == False
);
CU_ASSERT(en > 4 &&
ee[ 4].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE &&
ee[ 4].order_info.localmovesize.windowId == 0x0007008e &&
ee[ 4].order_info.localmovesize.isMoveSizeStart == True &&
ee[ 4].order_info.localmovesize.moveSizeType == RAIL_WMSZ_MOVE &&
ee[ 4].order_info.localmovesize.posX == 0x017e &&
ee[ 4].order_info.localmovesize.posY == 0x000a
);
CU_ASSERT(en > 5 &&
ee[ 5].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE &&
ee[ 5].order_info.localmovesize.windowId == 0x0007008e &&
ee[ 5].order_info.localmovesize.isMoveSizeStart == False &&
ee[ 5].order_info.localmovesize.moveSizeType == RAIL_WMSZ_MOVE &&
ee[ 5].order_info.localmovesize.posX == 0x00a6 &&
ee[ 5].order_info.localmovesize.posY == 0x0044
);
CU_ASSERT(en > 6 &&
ee[ 6].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO &&
ee[ 6].order_info.minmaxinfo.windowId == 0x0007008e &&
ee[ 6].order_info.minmaxinfo.maxWidth == 0x0408 &&
ee[ 6].order_info.minmaxinfo.maxHeight == 0x02d6 &&
ee[ 6].order_info.minmaxinfo.maxPosX == 0x0000 &&
ee[ 6].order_info.minmaxinfo.maxPosY == 0x0000 &&
ee[ 6].order_info.minmaxinfo.minTrackWidth == 0x0070 &&
ee[ 6].order_info.minmaxinfo.minTrackHeight == 0x001b &&
ee[ 6].order_info.minmaxinfo.maxTrackWidth == 0x040c &&
ee[ 6].order_info.minmaxinfo.maxTrackHeight == 0x030c
);
CU_ASSERT(en > 7 &&
ee[ 7].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO &&
ee[ 7].order_info.langbar_info.languageBarStatus == TF_SFT_SHOWNORMAL
);
CU_ASSERT(en > 8 &&
ee[ 8].event_type == RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP &&
ee[ 8].order_info.get_appid_resp.windowId == 0x00020052 &&
UNICODE_STRING_EQUAL_TO_DUMP(
&ee[ 8].order_info.get_appid_resp.applicationId,
server_app_get_resp_app_id
)
);
freerdp_channels_close(chan_man, inst);
freerdp_channels_free(chan_man);
}
void wf_context_new(freerdp* instance, rdpContext* context)
{
context->channels = freerdp_channels_new();
}
int tf_context_new(freerdp* instance, rdpContext* context)
{
context->channels = freerdp_channels_new();
return 0;
}
void test_cliprdr(void)
{
int i;
rdpChannels* channels;
rdpSettings settings = { 0 };
freerdp instance = { 0 };
RDP_EVENT* event;
RDP_CB_FORMAT_LIST_EVENT* format_list_event;
RDP_CB_DATA_REQUEST_EVENT* data_request_event;
RDP_CB_DATA_RESPONSE_EVENT* data_response_event;
settings.hostname = "testhost";
instance.settings = &settings;
instance.SendChannelData = test_rdp_channel_data;
channels = freerdp_channels_new();
freerdp_channels_load_plugin(channels, &settings, "../channels/cliprdr/cliprdr.so", NULL);
freerdp_channels_pre_connect(channels, &instance);
freerdp_channels_post_connect(channels, &instance);
/* server sends cliprdr capabilities and monitor ready PDU */
freerdp_channels_data(&instance, 0, (char*)test_clip_caps_data, sizeof(test_clip_caps_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_clip_caps_data) - 1);
freerdp_channels_data(&instance, 0, (char*)test_monitor_ready_data, sizeof(test_monitor_ready_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_monitor_ready_data) - 1);
/* cliprdr sends clipboard_sync event to UI */
while ((event = freerdp_channels_pop_event(channels)) == NULL)
{
freerdp_channels_check_fds(channels, &instance);
}
printf("Got event %d\n", event->event_type);
CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_MONITOR_READY);
freerdp_event_free(event);
/* UI sends format_list event to cliprdr */
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_FORMAT_LIST, event_process_callback, NULL);
format_list_event = (RDP_CB_FORMAT_LIST_EVENT*) event;
format_list_event->num_formats = 2;
format_list_event->formats = (uint32*) xmalloc(sizeof(uint32) * 2);
format_list_event->formats[0] = CB_FORMAT_TEXT;
format_list_event->formats[1] = CB_FORMAT_HTML;
event_processed = 0;
freerdp_channels_send_event(channels, event);
/* cliprdr sends format list PDU to server */
while (!event_processed)
{
freerdp_channels_check_fds(channels, &instance);
}
/* server sends format list response PDU to cliprdr */
freerdp_channels_data(&instance, 0, (char*)test_format_list_response_data, sizeof(test_format_list_response_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_format_list_response_data) - 1);
/* server sends format list PDU to cliprdr */
freerdp_channels_data(&instance, 0, (char*)test_format_list_data, sizeof(test_format_list_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_format_list_data) - 1);
/* cliprdr sends format_list event to UI */
while ((event = freerdp_channels_pop_event(channels)) == NULL)
{
freerdp_channels_check_fds(channels, &instance);
}
printf("Got event %d\n", event->event_type);
CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_FORMAT_LIST);
if (event->event_type == RDP_EVENT_TYPE_CB_FORMAT_LIST)
{
format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event;
for (i = 0; i < format_list_event->num_formats; i++)
printf("Format: 0x%X\n", format_list_event->formats[i]);
}
freerdp_event_free(event);
/* server sends data request PDU to cliprdr */
freerdp_channels_data(&instance, 0, (char*)test_data_request_data, sizeof(test_data_request_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_data_request_data) - 1);
/* cliprdr sends data request event to UI */
while ((event = freerdp_channels_pop_event(channels)) == NULL)
{
freerdp_channels_check_fds(channels, &instance);
}
printf("Got event %d\n", event->event_type);
CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_DATA_REQUEST);
if (event->event_type == RDP_EVENT_TYPE_CB_DATA_REQUEST)
{
data_request_event = (RDP_CB_DATA_REQUEST_EVENT*)event;
printf("Requested format: 0x%X\n", data_request_event->format);
}
freerdp_event_free(event);
/* UI sends data response event to cliprdr */
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_DATA_RESPONSE, event_process_callback, NULL);
data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
data_response_event->data = (uint8*)xmalloc(6);
strcpy((char*)data_response_event->data, "hello");
data_response_event->size = 6;
event_processed = 0;
freerdp_channels_send_event(channels, event);
/* cliprdr sends data response PDU to server */
while (!event_processed)
{
freerdp_channels_check_fds(channels, &instance);
}
/* UI sends data request event to cliprdr */
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_DATA_REQUEST, event_process_callback, NULL);
data_request_event = (RDP_CB_DATA_REQUEST_EVENT*)event;
data_request_event->format = CB_FORMAT_UNICODETEXT;
event_processed = 0;
freerdp_channels_send_event(channels, event);
/* cliprdr sends data request PDU to server */
while (!event_processed)
{
freerdp_channels_check_fds(channels, &instance);
}
/* server sends data response PDU to cliprdr */
freerdp_channels_data(&instance, 0, (char*)test_data_response_data, sizeof(test_data_response_data) - 1,
CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST, sizeof(test_data_response_data) - 1);
/* cliprdr sends data response event to UI */
while ((event = freerdp_channels_pop_event(channels)) == NULL)
{
freerdp_channels_check_fds(channels, &instance);
}
printf("Got event %d\n", event->event_type);
CU_ASSERT(event->event_type == RDP_EVENT_TYPE_CB_DATA_RESPONSE);
if (event->event_type == RDP_EVENT_TYPE_CB_DATA_RESPONSE)
{
data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
printf("Data response size: %d\n", data_response_event->size);
freerdp_hexdump(data_response_event->data, data_response_event->size);
}
freerdp_event_free(event);
freerdp_channels_close(channels, &instance);
freerdp_channels_free(channels);
}
void wf_context_new(freerdp* instance, wfContext* context)
{
rdpContext* _context = (rdpContext*) &context->_p;
context->channels = freerdp_channels_new();
}
int android_context_new(freerdp* instance, rdpContext* context)
{
context->channels = freerdp_channels_new();
android_event_queue_init(instance);
return 0;
}
/** Allocator function for a rdp context.
* The function will allocate a rdpRdp structure using rdp_new(), then copy
* its contents to the appropriate fields in the rdp_freerdp structure given in parameters.
* It will also initialize the 'context' field in the rdp_freerdp structure as needed.
* If the caller has set the ContextNew callback in the 'instance' parameter, it will be called at the end of the function.
*
* @param instance - Pointer to the rdp_freerdp structure that will be initialized with the new context.
*/
BOOL freerdp_context_new(freerdp* instance)
{
rdpRdp* rdp;
rdpContext* context;
BOOL ret = TRUE;
DWORD flags = WINPR_SSL_INIT_DEFAULT;
instance->context = (rdpContext*) calloc(1, instance->ContextSize);
if (!instance->context)
return FALSE;
context = instance->context;
context->instance = instance;
context->ServerMode = FALSE;
context->settings = instance->settings;
context->pubSub = PubSub_New(TRUE);
if (!context->pubSub)
goto fail;
PubSub_AddEventTypes(context->pubSub, FreeRDP_Events,
sizeof(FreeRDP_Events) / sizeof(wEventType));
context->metrics = metrics_new(context);
if (!context->metrics)
goto fail;
rdp = rdp_new(context);
if (!rdp)
goto fail;
instance->input = rdp->input;
instance->update = rdp->update;
instance->settings = rdp->settings;
instance->autodetect = rdp->autodetect;
context->graphics = graphics_new(context);
if (!context->graphics)
goto fail;
context->rdp = rdp;
context->input = instance->input;
context->update = instance->update;
context->settings = instance->settings;
context->autodetect = instance->autodetect;
instance->update->context = instance->context;
instance->update->pointer->context = instance->context;
instance->update->primary->context = instance->context;
instance->update->secondary->context = instance->context;
instance->update->altsec->context = instance->context;
instance->input->context = context;
instance->autodetect->context = context;
if (!(context->errorDescription = calloc(1, 500)))
{
WLog_ERR(TAG, "calloc failed!");
goto fail;
}
if (!(context->channelErrorEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
{
WLog_ERR(TAG, "CreateEvent failed!");
goto fail;
}
update_register_client_callbacks(rdp->update);
instance->context->abortEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!instance->context->abortEvent)
goto fail;
if (!(context->channels = freerdp_channels_new(instance)))
goto fail;
IFCALLRET(instance->ContextNew, ret, instance, instance->context);
if (ret)
return TRUE;
fail:
freerdp_context_free(instance);
return FALSE;
}
BOOL shw_freerdp_client_new(freerdp* instance, rdpContext* context)
{
shwContext* shw;
rdpSettings* settings;
shw = (shwContext*) instance->context;
if (!(shw->StopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
return FALSE;
if (!(context->channels = freerdp_channels_new()))
{
CloseHandle(shw->StopEvent);
shw->StopEvent = NULL;
return FALSE;
}
instance->PreConnect = shw_pre_connect;
instance->PostConnect = shw_post_connect;
instance->Authenticate = shw_authenticate;
instance->VerifyCertificate = shw_verify_certificate;
instance->VerifyX509Certificate = shw_verify_x509_certificate;
settings = instance->settings;
shw->settings = instance->context->settings;
settings->AsyncTransport = FALSE;
settings->AsyncChannels = FALSE;
settings->AsyncUpdate = FALSE;
settings->AsyncInput = FALSE;
settings->IgnoreCertificate = TRUE;
settings->ExternalCertificateManagement = TRUE;
settings->RdpSecurity = TRUE;
settings->TlsSecurity = TRUE;
settings->NlaSecurity = FALSE;
settings->BitmapCacheEnabled = FALSE;
settings->BitmapCacheV3Enabled = FALSE;
settings->OffscreenSupportLevel = FALSE;
settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE;
settings->BrushSupportLevel = FALSE;
ZeroMemory(settings->OrderSupport, 32);
settings->FrameMarkerCommandEnabled = TRUE;
settings->SurfaceFrameMarkerEnabled = TRUE;
settings->AltSecFrameMarkerSupport = TRUE;
settings->ColorDepth = 32;
settings->NSCodec = TRUE;
settings->RemoteFxCodec = TRUE;
settings->FastPathInput = TRUE;
settings->FastPathOutput = TRUE;
settings->LargePointerFlag = TRUE;
settings->CompressionEnabled = FALSE;
settings->AutoReconnectionEnabled = FALSE;
settings->NetworkAutoDetect = FALSE;
settings->SupportHeartbeatPdu = FALSE;
settings->SupportMultitransport = FALSE;
settings->ConnectionType = CONNECTION_TYPE_LAN;
settings->AllowFontSmoothing = TRUE;
settings->AllowDesktopComposition = TRUE;
settings->DisableWallpaper = FALSE;
settings->DisableFullWindowDrag = TRUE;
settings->DisableMenuAnims = TRUE;
settings->DisableThemes = FALSE;
settings->DeviceRedirection = TRUE;
settings->RedirectClipboard = TRUE;
settings->SupportDynamicChannels = TRUE;
return TRUE;
}
