From d7636d0e28130644986c9d1077482bde560d3ab2 Mon Sep 17 00:00:00 2001 From: Martin Haimberger Date: Mon, 8 Jun 2015 09:04:05 -0700 Subject: [PATCH] channel rail hardend --- channels/rail/client/rail_main.c | 305 +++++++++++++------ channels/rail/client/rail_main.h | 5 +- channels/rail/client/rail_orders.c | 461 +++++++++++++++++++---------- channels/rail/client/rail_orders.h | 48 +-- channels/rail/rail_common.c | 22 +- channels/rail/rail_common.h | 11 +- client/Windows/wf_rail.c | 32 +- client/X11/xf_rail.c | 40 +-- include/freerdp/client/rail.h | 41 +-- 9 files changed, 621 insertions(+), 344 deletions(-) diff --git a/channels/rail/client/rail_main.c b/channels/rail/client/rail_main.c index 113453c6a..aaec3ed6f 100644 --- a/channels/rail/client/rail_main.c +++ b/channels/rail/client/rail_main.c @@ -5,6 +5,8 @@ * Copyright 2011 Marc-Andre Moreau * Copyright 2011 Roman Barabanov * Copyright 2011 Vic Lee + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -38,9 +40,9 @@ RailClientContext* rail_get_client_interface(railPlugin* rail) return pInterface; } -int rail_send(railPlugin* rail, wStream* s) +WIN32ERROR rail_send(railPlugin* rail, wStream* s) { - UINT32 status = 0; + WIN32ERROR status; if (!rail) { @@ -62,21 +64,26 @@ int rail_send(railPlugin* rail, wStream* s) return status; } -BOOL rail_send_channel_data(railPlugin* rail, void* data, size_t length) +WIN32ERROR rail_send_channel_data(railPlugin* rail, void* data, size_t length) { wStream* s = NULL; s = Stream_New(NULL, length); + if (!s) + { + WLog_ERR(TAG, "Stream_New failed!"); + return CHANNEL_RC_NO_MEMORY; + } Stream_Write(s, data, length); - return rail_send(rail, s) == CHANNEL_RC_OK; + return rail_send(rail, s); } /** * Callback Interface */ -int rail_client_execute(RailClientContext* context, RAIL_EXEC_ORDER* exec) +WIN32ERROR rail_client_execute(RailClientContext* context, RAIL_EXEC_ORDER* exec) { char* exeOrFile; railPlugin* rail = (railPlugin*) context->handle; @@ -84,7 +91,7 @@ int rail_client_execute(RailClientContext* context, RAIL_EXEC_ORDER* exec) exeOrFile = exec->RemoteApplicationProgram; if (!exeOrFile) - return -1; + return ERROR_INVALID_PARAMETER; if (strlen(exeOrFile) >= 2) { @@ -96,22 +103,22 @@ int rail_client_execute(RailClientContext* context, RAIL_EXEC_ORDER* exec) rail_string_to_unicode_string(exec->RemoteApplicationWorkingDir, &exec->workingDir); /* ShellWorkingDirectory */ rail_string_to_unicode_string(exec->RemoteApplicationArguments, &exec->arguments); /* RemoteApplicationCmdLine */ - return rail_send_client_exec_order(rail, exec) ? 0 : -1; + return rail_send_client_exec_order(rail, exec); } -int rail_client_activate(RailClientContext* context, RAIL_ACTIVATE_ORDER* activate) +WIN32ERROR rail_client_activate(RailClientContext* context, RAIL_ACTIVATE_ORDER* activate) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_activate_order(rail, activate) ? 0 : -1; + return rail_send_client_activate_order(rail, activate); } -BOOL rail_send_client_sysparam(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_send_client_sysparam(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) { wStream* s; int length; - BOOL ret; railPlugin* rail = (railPlugin*) context->handle; + WIN32ERROR error; length = RAIL_SYSPARAM_ORDER_LENGTH; @@ -137,165 +144,205 @@ BOOL rail_send_client_sysparam(RailClientContext* context, RAIL_SYSPARAM_ORDER* s = rail_pdu_init(RAIL_SYSPARAM_ORDER_LENGTH + 8); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } - ret = rail_write_client_sysparam_order(s, sysparam) && - rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM); + if ((error = rail_write_client_sysparam_order(s, sysparam))) + { + WLog_ERR(TAG, "rail_write_client_sysparam_order failed with error %lu!", error); + Stream_Free(s, TRUE); + return error; + } + + if ((error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM))) + { + WLog_ERR(TAG, "rail_send_pdu failed with error %lu!", error); + } Stream_Free(s, TRUE); - return ret; + return error; } -int rail_client_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_client_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) { - BOOL ok = TRUE; + WIN32ERROR error = CHANNEL_RC_OK; if (sysparam->params & SPI_MASK_SET_HIGH_CONTRAST) { sysparam->param = SPI_SET_HIGH_CONTRAST; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_TASKBAR_POS) { sysparam->param = SPI_TASKBAR_POS; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_MOUSE_BUTTON_SWAP) { sysparam->param = SPI_SET_MOUSE_BUTTON_SWAP; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_KEYBOARD_PREF) { sysparam->param = SPI_SET_KEYBOARD_PREF; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_DRAG_FULL_WINDOWS) { sysparam->param = SPI_SET_DRAG_FULL_WINDOWS; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_KEYBOARD_CUES) { sysparam->param = SPI_SET_KEYBOARD_CUES; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_WORK_AREA) { sysparam->param = SPI_SET_WORK_AREA; - ok &= rail_send_client_sysparam(context, sysparam); + if ((error = rail_send_client_sysparam(context, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam failed with error %lu!", error); + return error; + } } - return ok ? 0 : -1; + return error; } -int rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_client_system_command(RailClientContext* context, RAIL_SYSCOMMAND_ORDER* syscommand) +WIN32ERROR rail_client_system_command(RailClientContext* context, RAIL_SYSCOMMAND_ORDER* syscommand) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_syscommand_order(rail, syscommand) ? 0 : -1; + return rail_send_client_syscommand_order(rail, syscommand); } -int rail_client_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) +WIN32ERROR rail_client_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_handshake_order(rail, handshake) ? 0 : -1; + return rail_send_handshake_order(rail, handshake); } -int rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) +WIN32ERROR rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_client_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +WIN32ERROR rail_client_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_handshake_ex_order(rail, handshakeEx) ? 0 : -1; + return rail_send_handshake_ex_order(rail, handshakeEx); } -int rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +WIN32ERROR rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_client_notify_event(RailClientContext* context, RAIL_NOTIFY_EVENT_ORDER* notifyEvent) +WIN32ERROR rail_client_notify_event(RailClientContext* context, RAIL_NOTIFY_EVENT_ORDER* notifyEvent) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_notify_event_order(rail, notifyEvent) ? 0 : -1; + return rail_send_client_notify_event_order(rail, notifyEvent); } -int rail_client_window_move(RailClientContext* context, RAIL_WINDOW_MOVE_ORDER* windowMove) +WIN32ERROR rail_client_window_move(RailClientContext* context, RAIL_WINDOW_MOVE_ORDER* windowMove) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_window_move_order(rail, windowMove) ? 0 : -1; + return rail_send_client_window_move_order(rail, windowMove); } -int rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) +WIN32ERROR rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) +WIN32ERROR rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_client_information(RailClientContext* context, RAIL_CLIENT_STATUS_ORDER* clientStatus) +WIN32ERROR rail_client_information(RailClientContext* context, RAIL_CLIENT_STATUS_ORDER* clientStatus) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_status_order(rail, clientStatus) ? 0 : -1; + return rail_send_client_status_order(rail, clientStatus); } -int rail_client_system_menu(RailClientContext* context, RAIL_SYSMENU_ORDER* sysmenu) +WIN32ERROR rail_client_system_menu(RailClientContext* context, RAIL_SYSMENU_ORDER* sysmenu) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_sysmenu_order(rail, sysmenu) ? 0 : -1; + return rail_send_client_sysmenu_order(rail, sysmenu); } -int rail_client_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) +WIN32ERROR rail_client_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_langbar_info_order(rail, langBarInfo) ? 0 : -1; + return rail_send_client_langbar_info_order(rail, langBarInfo); } -int rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) +WIN32ERROR rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) +WIN32ERROR rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } -int rail_client_get_appid_request(RailClientContext* context, RAIL_GET_APPID_REQ_ORDER* getAppIdReq) +WIN32ERROR rail_client_get_appid_request(RailClientContext* context, RAIL_GET_APPID_REQ_ORDER* getAppIdReq) { railPlugin* rail = (railPlugin*) context->handle; - return rail_send_client_get_appid_req_order(rail, getAppIdReq) ? 0 : -1; + return rail_send_client_get_appid_req_order(rail, getAppIdReq); } -int rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) +WIN32ERROR rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) { - return 0; /* stub - should be registered by client */ + return CHANNEL_RC_OK; /* stub - should be registered by client */ } /****************************************************************************************/ @@ -303,16 +350,24 @@ int rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RE static wListDictionary* g_InitHandles = NULL; static wListDictionary* g_OpenHandles = NULL; -BOOL rail_add_init_handle_data(void* pInitHandle, void* pUserData) +WIN32ERROR rail_add_init_handle_data(void* pInitHandle, void* pUserData) { if (!g_InitHandles) { g_InitHandles = ListDictionary_New(TRUE); - if (!g_InitHandles) - return FALSE; + } + if (!g_InitHandles) + { + WLog_ERR(TAG, "ListDictionary_New failed!"); + return CHANNEL_RC_NO_MEMORY; } - return ListDictionary_Add(g_InitHandles, pInitHandle, pUserData); + if (!ListDictionary_Add(g_InitHandles, pInitHandle, pUserData)) + { + WLog_ERR(TAG, "ListDictionary_Add failed!"); + return ERROR_INTERNAL_ERROR; + } + return CHANNEL_RC_OK; } void* rail_get_init_handle_data(void* pInitHandle) @@ -332,18 +387,26 @@ void rail_remove_init_handle_data(void* pInitHandle) } } -BOOL rail_add_open_handle_data(DWORD openHandle, void* pUserData) +WIN32ERROR rail_add_open_handle_data(DWORD openHandle, void* pUserData) { void* pOpenHandle = (void*) (size_t) openHandle; if (!g_OpenHandles) { g_OpenHandles = ListDictionary_New(TRUE); - if (!g_OpenHandles) - return FALSE; + } + if (!g_OpenHandles) + { + WLog_ERR(TAG, "ListDictionary_New failed!"); + return CHANNEL_RC_NO_MEMORY; } - return ListDictionary_Add(g_OpenHandles, pOpenHandle, pUserData); + ListDictionary_Add(g_OpenHandles, pOpenHandle, pUserData); + { + WLog_ERR(TAG, "ListDictionary_Add failed!"); + return ERROR_INTERNAL_ERROR; + } + return CHANNEL_RC_OK; } void* rail_get_open_handle_data(DWORD openHandle) @@ -365,14 +428,14 @@ void rail_remove_open_handle_data(DWORD openHandle) } } -static void rail_virtual_channel_event_data_received(railPlugin* rail, +static WIN32ERROR rail_virtual_channel_event_data_received(railPlugin* rail, void* pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) { wStream* data_in; if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME)) { - return; + return CHANNEL_RC_OK; } if (dataFlags & CHANNEL_FLAG_FIRST) @@ -383,16 +446,16 @@ static void rail_virtual_channel_event_data_received(railPlugin* rail, rail->data_in = Stream_New(NULL, totalLength); if (!rail->data_in) { - WLog_ERR(TAG, "%s: unable to allocate data_in", __FUNCTION__); - return; + WLog_ERR(TAG, "Stream_New failed!"); + return CHANNEL_RC_NO_MEMORY; } } data_in = rail->data_in; if (!Stream_EnsureRemainingCapacity(data_in, (int) dataLength)) { - WLog_ERR(TAG, "%s: unable to grow data_in to %d", __FUNCTION__, dataLength); - return; + WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!"); + return CHANNEL_RC_NO_MEMORY; } Stream_Write(data_in, pData, dataLength); @@ -401,6 +464,7 @@ static void rail_virtual_channel_event_data_received(railPlugin* rail, if (Stream_Capacity(data_in) != Stream_GetPosition(data_in)) { WLog_ERR(TAG, "rail_plugin_process_received: read error"); + return ERROR_INTERNAL_ERROR; } rail->data_in = NULL; @@ -409,6 +473,7 @@ static void rail_virtual_channel_event_data_received(railPlugin* rail, MessageQueue_Post(rail->queue, NULL, 0, (void*) data_in, NULL); } + return CHANNEL_RC_OK; } static VOID VCAPITYPE rail_virtual_channel_open_event(DWORD openHandle, UINT event, @@ -420,14 +485,20 @@ static VOID VCAPITYPE rail_virtual_channel_open_event(DWORD openHandle, UINT eve if (!rail) { - WLog_ERR(TAG, "rail_virtual_channel_open_event: error no match"); + WLog_ERR(TAG, "rail_virtual_channel_open_event: error no match"); + rail->error = CHANNEL_RC_BAD_CHANNEL; return; } + rail->error = CHANNEL_RC_OK; switch (event) { case CHANNEL_EVENT_DATA_RECEIVED: - rail_virtual_channel_event_data_received(rail, pData, dataLength, totalLength, dataFlags); + if ((rail->error = rail_virtual_channel_event_data_received(rail, pData, dataLength, totalLength, dataFlags))) + { + WLog_ERR(TAG, "rail_virtual_channel_event_data_received failed with error %lu!", rail->error); + return; + } break; case CHANNEL_EVENT_WRITE_COMPLETE: @@ -437,6 +508,8 @@ static VOID VCAPITYPE rail_virtual_channel_open_event(DWORD openHandle, UINT eve case CHANNEL_EVENT_USER: break; } + return; + //TODO report error } static void* rail_virtual_channel_client_thread(void* arg) @@ -444,6 +517,7 @@ static void* rail_virtual_channel_client_thread(void* arg) wStream* data; wMessage message; railPlugin* rail = (railPlugin*) arg; + WIN32ERROR error = CHANNEL_RC_OK; while (1) { @@ -458,48 +532,55 @@ static void* rail_virtual_channel_client_thread(void* arg) if (message.id == 0) { data = (wStream*) message.wParam; - if (!rail_order_recv(rail, data)) + if ((error = rail_order_recv(rail, data))) { - WLog_ERR(TAG, "%s: invalid message, exiting", __FUNCTION__); + WLog_ERR(TAG, "rail_order_recv failed with error %d!", error); break; } } } } - ExitThread(0); + ExitThread((DWORD)error); return NULL; } -static void rail_virtual_channel_event_connected(railPlugin* rail, LPVOID pData, UINT32 dataLength) +static WIN32ERROR rail_virtual_channel_event_connected(railPlugin* rail, LPVOID pData, UINT32 dataLength) { - UINT32 status; + WIN32ERROR status; status = rail->channelEntryPoints.pVirtualChannelOpen(rail->InitHandle, &rail->OpenHandle, rail->channelDef.name, rail_virtual_channel_open_event); - if (!rail_add_open_handle_data(rail->OpenHandle, rail)) - { - WLog_ERR(TAG, "%s: unable to register open handle", __FUNCTION__); - return; - } - if (status != CHANNEL_RC_OK) { - WLog_ERR(TAG, "pVirtualChannelOpen failed with %s [%08X]", + WLog_ERR(TAG, "pVirtualChannelOpen failed with %s [%08X]", WTSErrorToString(status), status); - return; + return status; + } + + if ((status = rail_add_open_handle_data(rail->OpenHandle, rail))) + { + WLog_ERR(TAG, "rail_add_open_handle_data failed with error %lu!", status); + return status; } rail->queue = MessageQueue_New(NULL); if (!rail->queue) { - WLog_ERR(TAG, "%s: unable to create a message queue", __FUNCTION__); - return; + WLog_ERR(TAG, "MessageQueue_New failed!"); + return CHANNEL_RC_NO_MEMORY; } - rail->thread = CreateThread(NULL, 0, - (LPTHREAD_START_ROUTINE) rail_virtual_channel_client_thread, (void*) rail, 0, NULL); + if (!(rail->thread = CreateThread(NULL, 0, + (LPTHREAD_START_ROUTINE) rail_virtual_channel_client_thread, (void*) rail, 0, NULL))) + { + WLog_ERR(TAG, "CreateThread failed!"); + MessageQueue_Free(rail->queue); + rail->queue = NULL; + return ERROR_INTERNAL_ERROR; + } + return CHANNEL_RC_OK; } static void rail_virtual_channel_event_disconnected(railPlugin* rail) @@ -545,13 +626,20 @@ static VOID VCAPITYPE rail_virtual_channel_init_event(LPVOID pInitHandle, UINT e if (!rail) { WLog_ERR(TAG, "rail_virtual_channel_init_event: error no match"); + rail->error = CHANNEL_RC_BAD_CHANNEL; return; } + rail->error = CHANNEL_RC_OK; + switch (event) { case CHANNEL_EVENT_CONNECTED: - rail_virtual_channel_event_connected(rail, pData, dataLength); + if ((rail->error = rail_virtual_channel_event_connected(rail, pData, dataLength))) + { + WLog_ERR(TAG, "rail_virtual_channel_event_connected failed with error %lu!", rail->error); + return; + } break; case CHANNEL_EVENT_DISCONNECTED: @@ -562,6 +650,8 @@ static VOID VCAPITYPE rail_virtual_channel_init_event(LPVOID pInitHandle, UINT e rail_virtual_channel_event_terminated(rail); break; } + return; + //TODO report error } /* rail is always built-in */ @@ -573,8 +663,15 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints) railPlugin* rail; RailClientContext* context; CHANNEL_ENTRY_POINTS_FREERDP* pEntryPointsEx; + BOOL isFreerdp = FALSE; + WIN32ERROR error; rail = (railPlugin*) calloc(1, sizeof(railPlugin)); + if (!rail) + { + WLog_ERR(TAG, "calloc failed!"); + return FALSE; + } rail->channelDef.options = CHANNEL_OPTION_INITIALIZED | @@ -591,7 +688,11 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints) { context = (RailClientContext*) calloc(1, sizeof(RailClientContext)); if (!context) + { + WLog_ERR(TAG, "calloc failed!"); + free(rail); return FALSE; + } context->handle = (void*) rail; context->custom = NULL; @@ -619,6 +720,7 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints) *(pEntryPointsEx->ppInterface) = (void*) context; rail->context = context; + isFreerdp = TRUE; } WLog_Init(); @@ -630,16 +732,27 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints) rc = rail->channelEntryPoints.pVirtualChannelInit(&rail->InitHandle, &rail->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000, rail_virtual_channel_init_event); + if (CHANNEL_RC_OK != rc) { WLog_ERR(TAG, "pVirtualChannelInit failed with %s [%08X]", WTSErrorToString(rc), rc); - free(rail); - return -1; + goto error_out; } rail->channelEntryPoints.pInterface = *(rail->channelEntryPoints.ppInterface); rail->channelEntryPoints.ppInterface = &(rail->channelEntryPoints.pInterface); - return rail_add_init_handle_data(rail->InitHandle, (void*) rail); + if ((error = rail_add_init_handle_data(rail->InitHandle, (void*) rail))) + { + WLog_ERR(TAG, "rail_add_init_handle_data failed with error %lu!", error); + goto error_out; + } + + return TRUE; +error_out: + if (isFreerdp) + free(rail->context); + free(rail); + return FALSE; } diff --git a/channels/rail/client/rail_main.h b/channels/rail/client/rail_main.h index dc589dbd4..62d1d55e6 100644 --- a/channels/rail/client/rail_main.h +++ b/channels/rail/client/rail_main.h @@ -5,6 +5,8 @@ * Copyright 2011 Marc-Andre Moreau * Copyright 2011 Roman Barabanov * Copyright 2011 Vic Lee + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -47,10 +49,11 @@ struct rail_plugin void* InitHandle; DWORD OpenHandle; wMessageQueue* queue; + WIN32ERROR error; }; typedef struct rail_plugin railPlugin; RailClientContext* rail_get_client_interface(railPlugin* rail); -BOOL rail_send_channel_data(railPlugin* rail, void* data, size_t length); +WIN32ERROR rail_send_channel_data(railPlugin* rail, void* data, size_t length); #endif /* FREERDP_CHANNEL_CLIENT_RAIL_MAIN_H */ diff --git a/channels/rail/client/rail_orders.c b/channels/rail/client/rail_orders.c index 813034c69..ef3fc1d03 100644 --- a/channels/rail/client/rail_orders.c +++ b/channels/rail/client/rail_orders.c @@ -4,6 +4,8 @@ * * Copyright 2009 Marc-Andre Moreau * Copyright 2011 Roman Barabanov + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -29,29 +31,35 @@ #include "rail_orders.h" -static BOOL rail_write_unicode_string(wStream* s, RAIL_UNICODE_STRING* unicode_string) +static WIN32ERROR rail_write_unicode_string(wStream* s, RAIL_UNICODE_STRING* unicode_string) { if (!Stream_EnsureRemainingCapacity(s, 2 + unicode_string->length)) - return FALSE; + { + WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!"); + return CHANNEL_RC_NO_MEMORY; + } Stream_Write_UINT16(s, unicode_string->length); /* cbString (2 bytes) */ Stream_Write(s, unicode_string->string, unicode_string->length); /* string */ - return TRUE; + return CHANNEL_RC_OK; } -static BOOL rail_write_unicode_string_value(wStream* s, RAIL_UNICODE_STRING* unicode_string) +static WIN32ERROR rail_write_unicode_string_value(wStream* s, RAIL_UNICODE_STRING* unicode_string) { if (unicode_string->length > 0) { if (!Stream_EnsureRemainingCapacity(s, unicode_string->length)) - return FALSE; + { + WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!"); + return CHANNEL_RC_NO_MEMORY; + } Stream_Write(s, unicode_string->string, unicode_string->length); /* string */ } - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType) +WIN32ERROR rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType) { UINT16 orderLength; @@ -67,7 +75,7 @@ BOOL rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType) return rail_send_channel_data(rail, Stream_Buffer(s), orderLength); } -BOOL rail_write_high_contrast(wStream* s, RAIL_HIGH_CONTRAST* highContrast) +WIN32ERROR rail_write_high_contrast(wStream* s, RAIL_HIGH_CONTRAST* highContrast) { highContrast->colorSchemeLength = highContrast->colorScheme.length + 2; Stream_Write_UINT32(s, highContrast->flags); /* flags (4 bytes) */ @@ -75,25 +83,31 @@ BOOL rail_write_high_contrast(wStream* s, RAIL_HIGH_CONTRAST* highContrast) return rail_write_unicode_string(s, &highContrast->colorScheme); /* colorScheme */ } -BOOL rail_read_server_exec_result_order(wStream* s, RAIL_EXEC_RESULT_ORDER* execResult) +WIN32ERROR rail_read_server_exec_result_order(wStream* s, RAIL_EXEC_RESULT_ORDER* execResult) { if (Stream_GetRemainingLength(s) < 8) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT16(s, execResult->flags); /* flags (2 bytes) */ Stream_Read_UINT16(s, execResult->execResult); /* execResult (2 bytes) */ Stream_Read_UINT32(s, execResult->rawResult); /* rawResult (4 bytes) */ Stream_Seek_UINT16(s); /* padding (2 bytes) */ - return rail_read_unicode_string(s, &execResult->exeOrFile); /* exeOrFile */ + return rail_read_unicode_string(s, &execResult->exeOrFile) ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR; /* exeOrFile */ } -BOOL rail_read_server_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_read_server_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) { BYTE body; if (Stream_GetRemainingLength(s) < 5) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT32(s, sysparam->param); /* systemParam (4 bytes) */ Stream_Read_UINT8(s, body); /* body (1 byte) */ @@ -112,13 +126,16 @@ BOOL rail_read_server_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) break; } - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_read_server_minmaxinfo_order(wStream* s, RAIL_MINMAXINFO_ORDER* minmaxinfo) +WIN32ERROR rail_read_server_minmaxinfo_order(wStream* s, RAIL_MINMAXINFO_ORDER* minmaxinfo) { if (Stream_GetRemainingLength(s) < 20) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT32(s, minmaxinfo->windowId); /* windowId (4 bytes) */ Stream_Read_UINT16(s, minmaxinfo->maxWidth); /* maxWidth (2 bytes) */ @@ -130,15 +147,18 @@ BOOL rail_read_server_minmaxinfo_order(wStream* s, RAIL_MINMAXINFO_ORDER* minmax Stream_Read_UINT16(s, minmaxinfo->maxTrackWidth); /* maxTrackWidth (2 bytes) */ Stream_Read_UINT16(s, minmaxinfo->maxTrackHeight); /* maxTrackHeight (2 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_read_server_localmovesize_order(wStream* s, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) +WIN32ERROR rail_read_server_localmovesize_order(wStream* s, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) { UINT16 isMoveSizeStart; if (Stream_GetRemainingLength(s) < 12) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT32(s, localMoveSize->windowId); /* windowId (4 bytes) */ @@ -149,28 +169,34 @@ BOOL rail_read_server_localmovesize_order(wStream* s, RAIL_LOCALMOVESIZE_ORDER* Stream_Read_UINT16(s, localMoveSize->posX); /* posX (2 bytes) */ Stream_Read_UINT16(s, localMoveSize->posY); /* posY (2 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_read_server_get_appid_resp_order(wStream* s, RAIL_GET_APPID_RESP_ORDER* getAppidResp) +WIN32ERROR rail_read_server_get_appid_resp_order(wStream* s, RAIL_GET_APPID_RESP_ORDER* getAppidResp) { if (Stream_GetRemainingLength(s) < 516) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT32(s, getAppidResp->windowId); /* windowId (4 bytes) */ Stream_Read(s, (BYTE*) &(getAppidResp->applicationId), 512); /* applicationId (256 UNICODE chars) */ - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_read_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbarInfo) +WIN32ERROR rail_read_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbarInfo) { if (Stream_GetRemainingLength(s) < 4) - return FALSE; + { + WLog_ERR(TAG, "Stream_GetRemainingLength failed!"); + return ERROR_INVALID_DATA; + } Stream_Read_UINT32(s, langbarInfo->languageBarStatus); /* languageBarStatus (4 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } void rail_write_client_status_order(wStream* s, RAIL_CLIENT_STATUS_ORDER* clientStatus) @@ -178,22 +204,32 @@ void rail_write_client_status_order(wStream* s, RAIL_CLIENT_STATUS_ORDER* client Stream_Write_UINT32(s, clientStatus->flags); /* flags (4 bytes) */ } -BOOL rail_write_client_exec_order(wStream* s, RAIL_EXEC_ORDER* exec) +WIN32ERROR rail_write_client_exec_order(wStream* s, RAIL_EXEC_ORDER* exec) { + WIN32ERROR error; Stream_Write_UINT16(s, exec->flags); /* flags (2 bytes) */ Stream_Write_UINT16(s, exec->exeOrFile.length); /* exeOrFileLength (2 bytes) */ Stream_Write_UINT16(s, exec->workingDir.length); /* workingDirLength (2 bytes) */ Stream_Write_UINT16(s, exec->arguments.length); /* argumentsLength (2 bytes) */ - - return rail_write_unicode_string_value(s, &exec->exeOrFile) && /* exeOrFile */ - rail_write_unicode_string_value(s, &exec->workingDir) && /* workingDir */ - rail_write_unicode_string_value(s, &exec->arguments); /* arguments */ + if ((error = rail_write_unicode_string_value(s, &exec->exeOrFile))) + { + return error; + } + if ((error = rail_write_unicode_string_value(s, &exec->workingDir))) + { + return error; + } + if ((error = rail_write_unicode_string_value(s, &exec->arguments))) + { + return error; + } + return error; } -BOOL rail_write_client_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_write_client_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) { BYTE body; - BOOL ret = TRUE; + WIN32ERROR error = CHANNEL_RC_OK; Stream_Write_UINT32(s, sysparam->param); /* systemParam (4 bytes) */ @@ -241,11 +277,11 @@ BOOL rail_write_client_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam) break; case SPI_SET_HIGH_CONTRAST: - ret = rail_write_high_contrast(s, &sysparam->highContrast); + error = rail_write_high_contrast(s, &sysparam->highContrast); break; } - return ret; + return error; } void rail_write_client_activate_order(wStream* s, RAIL_ACTIVATE_ORDER* activate) @@ -297,138 +333,173 @@ void rail_write_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbarI Stream_Write_UINT32(s, langbarInfo->languageBarStatus); /* languageBarStatus (4 bytes) */ } -BOOL rail_recv_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake, wStream* s) +WIN32ERROR rail_recv_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_handshake_order(s, handshake)) - return FALSE; + if ((error = rail_read_handshake_order(s, handshake))) + { + WLog_ERR(TAG, "rail_read_handshake_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerHandshake, context, handshake); - return TRUE; + IFCALLRET(context->ServerHandshake, error, context, handshake); } - return TRUE; + return error; } -BOOL rail_recv_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx, wStream* s) +WIN32ERROR rail_recv_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_handshake_ex_order(s, handshakeEx)) - return FALSE; + if ((error = rail_read_handshake_ex_order(s, handshakeEx))) + { + WLog_ERR(TAG, "rail_read_handshake_ex_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ClientHandshakeEx, context, handshakeEx); + IFCALLRET(context->ClientHandshakeEx, error, context, handshakeEx); } - return TRUE; + return error; } -BOOL rail_recv_exec_result_order(railPlugin* rail, RAIL_EXEC_RESULT_ORDER* execResult, wStream* s) +WIN32ERROR rail_recv_exec_result_order(railPlugin* rail, RAIL_EXEC_RESULT_ORDER* execResult, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; ZeroMemory(execResult, sizeof(RAIL_EXEC_RESULT_ORDER)); - if (!rail_read_server_exec_result_order(s, execResult)) - return FALSE; + if ((error = rail_read_server_exec_result_order(s, execResult))) + { + WLog_ERR(TAG, "rail_read_server_exec_result_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerExecuteResult, context, execResult); + IFCALLRET(context->ServerExecuteResult, error, context, execResult); } - return TRUE; + return error; } -BOOL rail_recv_server_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam, wStream* s) +WIN32ERROR rail_recv_server_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_server_sysparam_order(s, sysparam)) - return FALSE; + if ((error = rail_read_server_sysparam_order(s, sysparam))) + { + WLog_ERR(TAG, "rail_read_server_sysparam_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerSystemParam, context, sysparam); + IFCALLRET(context->ServerSystemParam, error, context, sysparam); } - return TRUE; + return error; } -BOOL rail_recv_server_minmaxinfo_order(railPlugin* rail, RAIL_MINMAXINFO_ORDER* minMaxInfo, wStream* s) +WIN32ERROR rail_recv_server_minmaxinfo_order(railPlugin* rail, RAIL_MINMAXINFO_ORDER* minMaxInfo, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_server_minmaxinfo_order(s, minMaxInfo)) - return FALSE; + if ((error = rail_read_server_minmaxinfo_order(s, minMaxInfo))) + { + WLog_ERR(TAG, "rail_read_server_minmaxinfo_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerMinMaxInfo, context, minMaxInfo); + IFCALLRET(context->ServerMinMaxInfo, error, context, minMaxInfo); } - return TRUE; + return error; } -BOOL rail_recv_server_localmovesize_order(railPlugin* rail, RAIL_LOCALMOVESIZE_ORDER* localMoveSize, wStream* s) +WIN32ERROR rail_recv_server_localmovesize_order(railPlugin* rail, RAIL_LOCALMOVESIZE_ORDER* localMoveSize, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_server_localmovesize_order(s, localMoveSize)) - return FALSE; + if ((error = rail_read_server_localmovesize_order(s, localMoveSize))) + { + WLog_ERR(TAG, "rail_read_server_localmovesize_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerLocalMoveSize, context, localMoveSize); + IFCALLRET(context->ServerLocalMoveSize, error, context, localMoveSize); } - return TRUE; + return error; } -BOOL rail_recv_server_get_appid_resp_order(railPlugin* rail, RAIL_GET_APPID_RESP_ORDER* getAppIdResp, wStream* s) +WIN32ERROR rail_recv_server_get_appid_resp_order(railPlugin* rail, RAIL_GET_APPID_RESP_ORDER* getAppIdResp, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_server_get_appid_resp_order(s, getAppIdResp)) - return FALSE; + if ((error = rail_read_server_get_appid_resp_order(s, getAppIdResp))) + { + WLog_ERR(TAG, "rail_read_server_get_appid_resp_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerGetAppIdResponse, context, getAppIdResp); + IFCALLRET(context->ServerGetAppIdResponse, error, context, getAppIdResp); } - return TRUE; + return error; } -BOOL rail_recv_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo, wStream* s) +WIN32ERROR rail_recv_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo, wStream* s) { RailClientContext* context = rail_get_client_interface(rail); + WIN32ERROR error; - if (!rail_read_langbar_info_order(s, langBarInfo)) - return FALSE; + if ((error = rail_read_langbar_info_order(s, langBarInfo))) + { + WLog_ERR(TAG, "rail_read_langbar_info_order failed with error %lu!", error); + return error; + } if (context->custom) { - IFCALL(context->ServerLanguageBarInfo, context, langBarInfo); + IFCALLRET(context->ServerLanguageBarInfo, error, context, langBarInfo); } - return TRUE; + return error; } -BOOL rail_order_recv(railPlugin* rail, wStream* s) +WIN32ERROR rail_order_recv(railPlugin* rail, wStream* s) { UINT16 orderType; UINT16 orderLength; + WIN32ERROR error; - if (!rail_read_pdu_header(s, &orderType, &orderLength)) - return FALSE; + if ((error = rail_read_pdu_header(s, &orderType, &orderLength))) + { + WLog_ERR(TAG, "rail_read_pdu_header failed with error %lu!", error); + return error; + } - WLog_Print(rail->log, WLOG_DEBUG, "Received %s PDU, length: %d", + WLog_Print(rail->log, WLOG_DEBUG, "Received %s PDU, length:%lu", RAIL_ORDER_TYPE_STRINGS[((orderType & 0xF0) >> 3) + (orderType & 0x0F)], orderLength); switch (orderType) @@ -483,61 +554,71 @@ BOOL rail_order_recv(railPlugin* rail, wStream* s) default: WLog_ERR(TAG, "Unknown RAIL PDU order reveived."); + return ERROR_INVALID_DATA; break; } - return TRUE; + return CHANNEL_RC_OK; } -BOOL rail_send_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake) +WIN32ERROR rail_send_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_HANDSHAKE_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_handshake_order(s, handshake); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_HANDSHAKE); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_HANDSHAKE); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +WIN32ERROR rail_send_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_HANDSHAKE_EX_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_handshake_ex_order(s, handshakeEx); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_HANDSHAKE_EX); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_HANDSHAKE_EX); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus) +WIN32ERROR rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_CLIENT_STATUS_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_status_order(s, clientStatus); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_CLIENTSTATUS); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_CLIENTSTATUS); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec) +WIN32ERROR rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec) { wStream* s; - BOOL ret; - int length; + WIN32ERROR error; + size_t length; length = RAIL_EXEC_ORDER_LENGTH + exec->exeOrFile.length + @@ -546,19 +627,30 @@ BOOL rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec) s = rail_pdu_init(length); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } - ret = rail_write_client_exec_order(s, exec) && - rail_send_pdu(rail, s, RDP_RAIL_ORDER_EXEC); + if ((error = rail_write_client_exec_order(s, exec))) + { + WLog_ERR(TAG, "rail_write_client_exec_order failed with error %lu!", error); + return error; + } + if ((error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_EXEC))) + { + WLog_ERR(TAG, "rail_send_pdu failed with error %lu!", error); + return error; + } Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam) { wStream* s; int length; - BOOL ret = FALSE; + WIN32ERROR error; length = RAIL_SYSPARAM_ORDER_LENGTH; @@ -584,165 +676,226 @@ BOOL rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysp s = rail_pdu_init(RAIL_SYSPARAM_ORDER_LENGTH + 8); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } - ret = rail_write_client_sysparam_order(s, sysparam) && - rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM); + if ((error = rail_write_client_sysparam_order(s, sysparam))) + { + WLog_ERR(TAG, "rail_write_client_sysparam_order failed with error %lu!", error); + return error; + } + + if ((error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM))) + { + WLog_ERR(TAG, "rail_send_pdu failed with error %lu!", error); + return error; + } Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam) +WIN32ERROR rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam) { - BOOL ret = TRUE; + WIN32ERROR error = CHANNEL_RC_OK; if (sysparam->params & SPI_MASK_SET_HIGH_CONTRAST) { sysparam->param = SPI_SET_HIGH_CONTRAST; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_TASKBAR_POS) { sysparam->param = SPI_TASKBAR_POS; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_MOUSE_BUTTON_SWAP) { sysparam->param = SPI_SET_MOUSE_BUTTON_SWAP; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_KEYBOARD_PREF) { sysparam->param = SPI_SET_KEYBOARD_PREF; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_DRAG_FULL_WINDOWS) { sysparam->param = SPI_SET_DRAG_FULL_WINDOWS; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_KEYBOARD_CUES) { sysparam->param = SPI_SET_KEYBOARD_CUES; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } if (sysparam->params & SPI_MASK_SET_WORK_AREA) { sysparam->param = SPI_SET_WORK_AREA; - ret &= rail_send_client_sysparam_order(rail, sysparam); + if ((error = rail_send_client_sysparam_order(rail, sysparam))) + { + WLog_ERR(TAG, "rail_send_client_sysparam_order failed with error %lu!", error); + return error; + } } - return ret; + return error; } -BOOL rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate) +WIN32ERROR rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_ACTIVATE_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_activate_order(s, activate); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_ACTIVATE); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_ACTIVATE); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu) +WIN32ERROR rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_SYSMENU_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_sysmenu_order(s, sysmenu); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSMENU); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSMENU); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand) +WIN32ERROR rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_SYSCOMMAND_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_syscommand_order(s, syscommand); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSCOMMAND); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSCOMMAND); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent) +WIN32ERROR rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_NOTIFY_EVENT_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_notify_event_order(s, notifyEvent); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_NOTIFY_EVENT); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_NOTIFY_EVENT); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove) +WIN32ERROR rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_WINDOW_MOVE_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_window_move_order(s, windowMove); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_WINDOWMOVE); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_WINDOWMOVE); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq) +WIN32ERROR rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_GET_APPID_REQ_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_client_get_appid_req_order(s, getAppIdReq); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_GET_APPID_REQ); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_GET_APPID_REQ); Stream_Free(s, TRUE); - return ret; + return error; } -BOOL rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo) +WIN32ERROR rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo) { wStream* s; - BOOL ret; + WIN32ERROR error; s = rail_pdu_init(RAIL_LANGBAR_INFO_ORDER_LENGTH); if (!s) - return FALSE; + { + WLog_ERR(TAG, "rail_pdu_init failed!"); + return CHANNEL_RC_NO_MEMORY; + } rail_write_langbar_info_order(s, langBarInfo); - ret = rail_send_pdu(rail, s, RDP_RAIL_ORDER_LANGBARINFO); + error = rail_send_pdu(rail, s, RDP_RAIL_ORDER_LANGBARINFO); Stream_Free(s, TRUE); - return ret; + return error; } diff --git a/channels/rail/client/rail_orders.h b/channels/rail/client/rail_orders.h index 7aa34a883..c6dbb9214 100644 --- a/channels/rail/client/rail_orders.h +++ b/channels/rail/client/rail_orders.h @@ -4,6 +4,8 @@ * * Copyright 2009 Marc-Andre Moreau * Copyright 2011 Roman Barabanov + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,16 +29,16 @@ #define TAG CHANNELS_TAG("rail.client") -BOOL rail_read_server_exec_result_order(wStream* s, RAIL_EXEC_RESULT_ORDER* exec_result); -BOOL rail_read_server_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam); -BOOL rail_read_server_minmaxinfo_order(wStream* s, RAIL_MINMAXINFO_ORDER* minmaxinfo); -BOOL rail_read_server_localmovesize_order(wStream* s, RAIL_LOCALMOVESIZE_ORDER* localmovesize); -BOOL rail_read_server_get_appid_resp_order(wStream* s, RAIL_GET_APPID_RESP_ORDER* get_appid_resp); -BOOL rail_read_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbar_info); +WIN32ERROR rail_read_server_exec_result_order(wStream* s, RAIL_EXEC_RESULT_ORDER* exec_result); +WIN32ERROR rail_read_server_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam); +WIN32ERROR rail_read_server_minmaxinfo_order(wStream* s, RAIL_MINMAXINFO_ORDER* minmaxinfo); +WIN32ERROR rail_read_server_localmovesize_order(wStream* s, RAIL_LOCALMOVESIZE_ORDER* localmovesize); +WIN32ERROR rail_read_server_get_appid_resp_order(wStream* s, RAIL_GET_APPID_RESP_ORDER* get_appid_resp); +WIN32ERROR rail_read_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbar_info); void rail_write_client_status_order(wStream* s, RAIL_CLIENT_STATUS_ORDER* client_status); -BOOL rail_write_client_exec_order(wStream* s, RAIL_EXEC_ORDER* exec); -BOOL rail_write_client_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam); +WIN32ERROR rail_write_client_exec_order(wStream* s, RAIL_EXEC_ORDER* exec); +WIN32ERROR rail_write_client_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam); void rail_write_client_activate_order(wStream* s, RAIL_ACTIVATE_ORDER* activate); void rail_write_client_sysmenu_order(wStream* s, RAIL_SYSMENU_ORDER* sysmenu); void rail_write_client_syscommand_order(wStream* s, RAIL_SYSCOMMAND_ORDER* syscommand); @@ -45,21 +47,21 @@ void rail_write_client_window_move_order(wStream* s, RAIL_WINDOW_MOVE_ORDER* win void rail_write_client_get_appid_req_order(wStream* s, RAIL_GET_APPID_REQ_ORDER* get_appid_req); void rail_write_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbar_info); -BOOL rail_order_recv(railPlugin* rail, wStream* s); -BOOL rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType); +WIN32ERROR rail_order_recv(railPlugin* rail, wStream* s); +WIN32ERROR rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType); -BOOL rail_send_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake); -BOOL rail_send_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); -BOOL rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus); -BOOL rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec); -BOOL rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam); -BOOL rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam); -BOOL rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate); -BOOL rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu); -BOOL rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand); -BOOL rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent); -BOOL rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove); -BOOL rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq); -BOOL rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo); +WIN32ERROR rail_send_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake); +WIN32ERROR rail_send_handshake_ex_order(railPlugin* rail, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); +WIN32ERROR rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus); +WIN32ERROR rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec); +WIN32ERROR rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam); +WIN32ERROR rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam); +WIN32ERROR rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate); +WIN32ERROR rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu); +WIN32ERROR rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand); +WIN32ERROR rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent); +WIN32ERROR rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove); +WIN32ERROR rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq); +WIN32ERROR rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo); #endif /* __RAIL_ORDERS_H */ diff --git a/channels/rail/rail_common.c b/channels/rail/rail_common.c index 564c702e9..82dc22b57 100644 --- a/channels/rail/rail_common.c +++ b/channels/rail/rail_common.c @@ -5,6 +5,8 @@ * Copyright 2011 Marc-Andre Moreau * Copyright 2011 Roman Barabanov * Copyright 2011 Vic Lee + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -68,15 +70,15 @@ void rail_string_to_unicode_string(char* string, RAIL_UNICODE_STRING* unicode_st unicode_string->length = (UINT16) length; } -BOOL rail_read_pdu_header(wStream* s, UINT16* orderType, UINT16* orderLength) +WIN32ERROR rail_read_pdu_header(wStream* s, UINT16* orderType, UINT16* orderLength) { if (Stream_GetRemainingLength(s) < 4) - return FALSE; + return ERROR_INVALID_DATA; Stream_Read_UINT16(s, *orderType); /* orderType (2 bytes) */ Stream_Read_UINT16(s, *orderLength); /* orderLength (2 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } void rail_write_pdu_header(wStream* s, UINT16 orderType, UINT16 orderLength) @@ -85,7 +87,7 @@ void rail_write_pdu_header(wStream* s, UINT16 orderType, UINT16 orderLength) Stream_Write_UINT16(s, orderLength); /* orderLength (2 bytes) */ } -wStream* rail_pdu_init(int length) +wStream* rail_pdu_init(size_t length) { wStream* s; s = Stream_New(NULL, length + RAIL_PDU_HEADER_LENGTH); @@ -95,14 +97,14 @@ wStream* rail_pdu_init(int length) return s; } -BOOL rail_read_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake) +WIN32ERROR rail_read_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake) { if (Stream_GetRemainingLength(s) < 4) - return FALSE; + return ERROR_INVALID_DATA; Stream_Read_UINT32(s, handshake->buildNumber); /* buildNumber (4 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } void rail_write_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake) @@ -110,15 +112,15 @@ void rail_write_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake) Stream_Write_UINT32(s, handshake->buildNumber); /* buildNumber (4 bytes) */ } -BOOL rail_read_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +WIN32ERROR rail_read_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { if (Stream_GetRemainingLength(s) < 8) - return FALSE; + return ERROR_INVALID_DATA; Stream_Read_UINT32(s, handshakeEx->buildNumber); /* buildNumber (4 bytes) */ Stream_Read_UINT32(s, handshakeEx->railHandshakeFlags); /* railHandshakeFlags (4 bytes) */ - return TRUE; + return CHANNEL_RC_OK; } void rail_write_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) diff --git a/channels/rail/rail_common.h b/channels/rail/rail_common.h index 047005687..3a552cd1d 100644 --- a/channels/rail/rail_common.h +++ b/channels/rail/rail_common.h @@ -5,6 +5,8 @@ * Copyright 2011 Marc-Andre Moreau * Copyright 2011 Roman Barabanov * Copyright 2011 Vic Lee + * Copyright 2015 Thincast Technologies GmbH + * Copyright 2015 DI (FH) Martin Haimberger * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,6 +25,7 @@ #define FREERDP_CHANNEL_RAIL_COMMON_H #include +#include extern const char* const RAIL_ORDER_TYPE_STRINGS[]; @@ -43,13 +46,13 @@ extern const char* const RAIL_ORDER_TYPE_STRINGS[]; #define RAIL_LANGBAR_INFO_ORDER_LENGTH 4 /* fixed */ void rail_string_to_unicode_string(char* string, RAIL_UNICODE_STRING* unicode_string); -BOOL rail_read_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake); +WIN32ERROR rail_read_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake); void rail_write_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake); -BOOL rail_read_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); +WIN32ERROR rail_read_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); void rail_write_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); -wStream* rail_pdu_init(int length); -BOOL rail_read_pdu_header(wStream* s, UINT16* orderType, UINT16* orderLength); +wStream* rail_pdu_init(size_t length); +WIN32ERROR rail_read_pdu_header(wStream* s, UINT16* orderType, UINT16* orderLength); void rail_write_pdu_header(wStream* s, UINT16 orderType, UINT16 orderLength); #endif /* FREERDP_CHANNEL_RAIL_COMMON_H */ diff --git a/client/Windows/wf_rail.c b/client/Windows/wf_rail.c index 268693018..c93144eab 100644 --- a/client/Windows/wf_rail.c +++ b/client/Windows/wf_rail.c @@ -860,18 +860,18 @@ void wf_rail_register_update_callbacks(rdpUpdate* update) /* RemoteApp Virtual Channel Extension */ -static int wf_rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) +static WIN32ERROR wf_rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) { WLog_DBG(TAG, "RailServerExecuteResult: 0x%04X", execResult->rawResult); - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) +static WIN32ERROR wf_rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) { - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) +static WIN32ERROR wf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) { RAIL_EXEC_ORDER exec; RAIL_SYSPARAM_ORDER sysparam; @@ -933,32 +933,32 @@ static int wf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_O context->ClientExecute(context, &exec); - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +static WIN32ERROR wf_rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) +static WIN32ERROR wf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) { - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) +static WIN32ERROR wf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) { - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) +static WIN32ERROR wf_rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) { - return 1; + return CHANNEL_RC_OK; } -static int wf_rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) +static WIN32ERROR wf_rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) { - return 1; + return CHANNEL_RC_OK; } void wf_rail_invalidate_region(wfContext* wfc, REGION16* invalidRegion) diff --git a/client/X11/xf_rail.c b/client/X11/xf_rail.c index ccfe6b0c0..28c072e75 100644 --- a/client/X11/xf_rail.c +++ b/client/X11/xf_rail.c @@ -628,7 +628,7 @@ void xf_rail_register_update_callbacks(rdpUpdate* update) /* RemoteApp Virtual Channel Extension */ -static int xf_rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) +static WIN32ERROR xf_rail_server_execute_result(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult) { xfContext* xfc = (xfContext*) context->custom; @@ -643,15 +643,15 @@ static int xf_rail_server_execute_result(RailClientContext* context, RAIL_EXEC_R xf_rail_enable_remoteapp_mode(xfc); } - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) +static WIN32ERROR xf_rail_server_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam) { - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) +static WIN32ERROR xf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake) { RAIL_EXEC_ORDER exec; RAIL_SYSPARAM_ORDER sysparam; @@ -713,15 +713,15 @@ static int xf_rail_server_handshake(RailClientContext* context, RAIL_HANDSHAKE_O context->ClientExecute(context, &exec); - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) +static WIN32ERROR xf_rail_server_handshake_ex(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx) { - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) +static WIN32ERROR xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize) { int x = 0, y = 0; int direction = 0; @@ -733,7 +733,7 @@ static int xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCAL (void*) (UINT_PTR) localMoveSize->windowId); if (!appWindow) - return -1; + return ERROR_INTERNAL_ERROR; switch (localMoveSize->moveSizeType) { @@ -797,7 +797,7 @@ static int xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCAL x = localMoveSize->posX; y = localMoveSize->posY; /* FIXME: local keyboard moves not working */ - return 1; + return CHANNEL_RC_OK; break; case RAIL_WMSZ_KEYSIZE: @@ -805,7 +805,7 @@ static int xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCAL x = localMoveSize->posX; y = localMoveSize->posY; /* FIXME: local keyboard moves not working */ - return 1; + return CHANNEL_RC_OK; break; } @@ -818,10 +818,10 @@ static int xf_rail_server_local_move_size(RailClientContext* context, RAIL_LOCAL xf_EndLocalMoveSize(xfc, appWindow); } - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) +static WIN32ERROR xf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo) { xfAppWindow* appWindow = NULL; xfContext* xfc = (xfContext*) context->custom; @@ -830,7 +830,7 @@ static int xf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXIN (void*) (UINT_PTR) minMaxInfo->windowId); if (!appWindow) - return -1; + return ERROR_INTERNAL_ERROR; xf_SetWindowMinMaxInfo(xfc, appWindow, minMaxInfo->maxWidth, minMaxInfo->maxHeight, @@ -838,17 +838,17 @@ static int xf_rail_server_min_max_info(RailClientContext* context, RAIL_MINMAXIN minMaxInfo->minTrackWidth, minMaxInfo->minTrackHeight, minMaxInfo->maxTrackWidth, minMaxInfo->maxTrackHeight); - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) +static WIN32ERROR xf_rail_server_language_bar_info(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo) { - return 1; + return CHANNEL_RC_OK; } -static int xf_rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) +static WIN32ERROR xf_rail_server_get_appid_response(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp) { - return 1; + return CHANNEL_RC_OK; } int xf_rail_init(xfContext* xfc, RailClientContext* rail) diff --git a/include/freerdp/client/rail.h b/include/freerdp/client/rail.h index 4636029d7..79d974234 100644 --- a/include/freerdp/client/rail.h +++ b/include/freerdp/client/rail.h @@ -26,6 +26,7 @@ #include #include #include +#include /** * Client Interface @@ -35,26 +36,26 @@ typedef struct _rail_client_context RailClientContext; -typedef int (*pcRailClientExecute)(RailClientContext* context, RAIL_EXEC_ORDER* exec); -typedef int (*pcRailClientActivate)(RailClientContext* context, RAIL_ACTIVATE_ORDER* activate); -typedef int (*pcRailClientSystemParam)(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam); -typedef int (*pcRailServerSystemParam)(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam); -typedef int (*pcRailClientSystemCommand)(RailClientContext* context, RAIL_SYSCOMMAND_ORDER* syscommand); -typedef int (*pcRailClientHandshake)(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake); -typedef int (*pcRailServerHandshake)(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake); -typedef int (*pcRailClientHandshakeEx)(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); -typedef int (*pcRailServerHandshakeEx)(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); -typedef int (*pcRailClientNotifyEvent)(RailClientContext* context, RAIL_NOTIFY_EVENT_ORDER* notifyEvent); -typedef int (*pcRailClientWindowMove)(RailClientContext* context, RAIL_WINDOW_MOVE_ORDER* windowMove); -typedef int (*pcRailServerLocalMoveSize)(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize); -typedef int (*pcRailServerMinMaxInfo)(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo); -typedef int (*pcRailClientInformation)(RailClientContext* context, RAIL_CLIENT_STATUS_ORDER* clientStatus); -typedef int (*pcRailClientSystemMenu)(RailClientContext* context, RAIL_SYSMENU_ORDER* sysmenu); -typedef int (*pcRailClientLanguageBarInfo)(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo); -typedef int (*pcRailServerLanguageBarInfo)(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo); -typedef int (*pcRailServerExecuteResult)(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult); -typedef int (*pcRailClientGetAppIdRequest)(RailClientContext* context, RAIL_GET_APPID_REQ_ORDER* getAppIdReq); -typedef int (*pcRailServerGetAppIdResponse)(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp); +typedef WIN32ERROR (*pcRailClientExecute)(RailClientContext* context, RAIL_EXEC_ORDER* exec); +typedef WIN32ERROR (*pcRailClientActivate)(RailClientContext* context, RAIL_ACTIVATE_ORDER* activate); +typedef WIN32ERROR (*pcRailClientSystemParam)(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam); +typedef WIN32ERROR (*pcRailServerSystemParam)(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam); +typedef WIN32ERROR (*pcRailClientSystemCommand)(RailClientContext* context, RAIL_SYSCOMMAND_ORDER* syscommand); +typedef WIN32ERROR (*pcRailClientHandshake)(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake); +typedef WIN32ERROR (*pcRailServerHandshake)(RailClientContext* context, RAIL_HANDSHAKE_ORDER* handshake); +typedef WIN32ERROR (*pcRailClientHandshakeEx)(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); +typedef WIN32ERROR (*pcRailServerHandshakeEx)(RailClientContext* context, RAIL_HANDSHAKE_EX_ORDER* handshakeEx); +typedef WIN32ERROR (*pcRailClientNotifyEvent)(RailClientContext* context, RAIL_NOTIFY_EVENT_ORDER* notifyEvent); +typedef WIN32ERROR (*pcRailClientWindowMove)(RailClientContext* context, RAIL_WINDOW_MOVE_ORDER* windowMove); +typedef WIN32ERROR (*pcRailServerLocalMoveSize)(RailClientContext* context, RAIL_LOCALMOVESIZE_ORDER* localMoveSize); +typedef WIN32ERROR (*pcRailServerMinMaxInfo)(RailClientContext* context, RAIL_MINMAXINFO_ORDER* minMaxInfo); +typedef WIN32ERROR (*pcRailClientInformation)(RailClientContext* context, RAIL_CLIENT_STATUS_ORDER* clientStatus); +typedef WIN32ERROR (*pcRailClientSystemMenu)(RailClientContext* context, RAIL_SYSMENU_ORDER* sysmenu); +typedef WIN32ERROR (*pcRailClientLanguageBarInfo)(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo); +typedef WIN32ERROR (*pcRailServerLanguageBarInfo)(RailClientContext* context, RAIL_LANGBAR_INFO_ORDER* langBarInfo); +typedef WIN32ERROR (*pcRailServerExecuteResult)(RailClientContext* context, RAIL_EXEC_RESULT_ORDER* execResult); +typedef WIN32ERROR (*pcRailClientGetAppIdRequest)(RailClientContext* context, RAIL_GET_APPID_REQ_ORDER* getAppIdReq); +typedef WIN32ERROR (*pcRailServerGetAppIdResponse)(RailClientContext* context, RAIL_GET_APPID_RESP_ORDER* getAppIdResp); struct _rail_client_context {