morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-15 00:44:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

channels/rail: start refactoring

Browse Source
This commit is contained in:
Marc-André Moreau
2013-10-14 23:16:40 -04:00
parent 3880640132
commit 7be92579b2
6 changed files with 216 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
channels/rail/client/rail_main.c
View File

@@ -38,6 +38,14 @@
#include "rail_orders.h"
#include "rail_main.h"
RailClientContext* rail_get_client_interface(void* railObject)
{
RailClientContext* pInterface;
rdpSvcPlugin* plugin = (rdpSvcPlugin*) railObject;
pInterface = (RailClientContext*) *(plugin->channel_entry_points.ppInterface);
return pInterface;
}
void rail_send_channel_data(void* railObject, void* data, size_t length)
{
wStream* s = NULL;
@@ -54,17 +62,17 @@ static void on_free_rail_channel_event(wMessage* event)
rail_free_cloned_order(GetMessageType(event->id), event->wParam);
}
void rail_send_channel_event(void* rail_object, UINT16 event_type, void* param)
void rail_send_channel_event(void* railObject, UINT16 eventType, void* param)
{
void* payload = NULL;
wMessage* out_event = NULL;
railPlugin* plugin = (railPlugin*) rail_object;
railPlugin* plugin = (railPlugin*) railObject;
payload = rail_clone_order(event_type, param);
payload = rail_clone_order(eventType, param);
if (payload)
{
out_event = freerdp_event_new(RailChannel_Class, event_type,
out_event = freerdp_event_new(RailChannel_Class, eventType,
on_free_rail_channel_event, payload);
svc_plugin_send_event((rdpSvcPlugin*) plugin, out_event);
@@ -96,7 +104,7 @@ static void rail_process_receive(rdpSvcPlugin* plugin, wStream* s)
Stream_Free(s, TRUE);
}
static void rail_process_addin_args(rdpRailOrder* rail_order, rdpSettings* settings)
static void rail_process_addin_args(rdpRailOrder* railOrder, rdpSettings* settings)
{
char* exeOrFile;
@@ -105,32 +113,32 @@ static void rail_process_addin_args(rdpRailOrder* rail_order, rdpSettings* setti
if (strlen(exeOrFile) >= 2)
{
if (strncmp(exeOrFile, "||", 2) != 0)
rail_order->exec.flags |= RAIL_EXEC_FLAG_FILE;
railOrder->exec.flags |= RAIL_EXEC_FLAG_FILE;
}
rail_string_to_unicode_string(settings->RemoteApplicationProgram, &rail_order->exec.exeOrFile);
rail_string_to_unicode_string(settings->ShellWorkingDirectory, &rail_order->exec.workingDir);
rail_string_to_unicode_string(settings->RemoteApplicationCmdLine, &rail_order->exec.arguments);
rail_string_to_unicode_string(settings->RemoteApplicationProgram, &railOrder->exec.exeOrFile);
rail_string_to_unicode_string(settings->ShellWorkingDirectory, &railOrder->exec.workingDir);
rail_string_to_unicode_string(settings->RemoteApplicationCmdLine, &railOrder->exec.arguments);
rail_send_client_exec_order(rail_order);
rail_send_client_exec_order((railPlugin*) railOrder->plugin, &railOrder->exec);
}
static void rail_recv_set_sysparams_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_set_sysparams_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_SYSPARAM_ORDER* sysparam;
/* Send System Parameters */
sysparam = (RAIL_SYSPARAM_ORDER*) event->wParam;
memmove(&rail_order->sysparam, sysparam, sizeof(RAIL_SYSPARAM_ORDER));
memmove(&railOrder->sysparam, sysparam, sizeof(RAIL_SYSPARAM_ORDER));
rail_send_client_sysparams_order(rail_order);
rail_send_client_sysparams_order(railOrder);
/* execute */
rail_order->exec.flags = RAIL_EXEC_FLAG_EXPAND_ARGUMENTS;
railOrder->exec.flags = RAIL_EXEC_FLAG_EXPAND_ARGUMENTS;
rail_process_addin_args(rail_order, rail_order->settings);
rail_process_addin_args(railOrder, railOrder->settings);
}
static void rail_recv_exec_remote_app_event(rdpRailOrder* rail_order, wMessage* event)
@@ -144,12 +152,12 @@ static void rail_recv_exec_remote_app_event(rdpRailOrder* rail_order, wMessage*
//rail_process_addin_args(rail_order, data);
}
static void rail_recv_activate_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_activate_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_ACTIVATE_ORDER* activate = (RAIL_ACTIVATE_ORDER*) event->wParam;
CopyMemory(&rail_order->activate, activate, sizeof(RAIL_ACTIVATE_ORDER));
rail_send_client_activate_order(rail_order);
CopyMemory(&railOrder->activate, activate, sizeof(RAIL_ACTIVATE_ORDER));
rail_send_client_activate_order(railOrder);
}
static void rail_recv_sysmenu_event(rdpRailOrder* rail_order, wMessage* event)
@@ -160,44 +168,44 @@ static void rail_recv_sysmenu_event(rdpRailOrder* rail_order, wMessage* event)
rail_send_client_sysmenu_order(rail_order);
}
static void rail_recv_syscommand_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_syscommand_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_SYSCOMMAND_ORDER* syscommand = (RAIL_SYSCOMMAND_ORDER*) event->wParam;
CopyMemory(&rail_order->syscommand, syscommand, sizeof(RAIL_SYSCOMMAND_ORDER));
rail_send_client_syscommand_order(rail_order);
CopyMemory(&railOrder->syscommand, syscommand, sizeof(RAIL_SYSCOMMAND_ORDER));
rail_send_client_syscommand_order(railOrder);
}
static void rail_recv_notify_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_notify_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_NOTIFY_EVENT_ORDER* notify = (RAIL_NOTIFY_EVENT_ORDER*) event->wParam;
CopyMemory(&rail_order->notify_event, notify, sizeof(RAIL_NOTIFY_EVENT_ORDER));
rail_send_client_notify_event_order(rail_order);
CopyMemory(&railOrder->notify_event, notify, sizeof(RAIL_NOTIFY_EVENT_ORDER));
rail_send_client_notify_event_order(railOrder);
}
static void rail_recv_window_move_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_window_move_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_WINDOW_MOVE_ORDER* window_move = (RAIL_WINDOW_MOVE_ORDER*) event->wParam;
CopyMemory(&rail_order->window_move, window_move, sizeof(RAIL_WINDOW_MOVE_ORDER));
rail_send_client_window_move_order(rail_order);
CopyMemory(&railOrder->window_move, window_move, sizeof(RAIL_WINDOW_MOVE_ORDER));
rail_send_client_window_move_order(railOrder);
}
static void rail_recv_app_req_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_app_req_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_GET_APPID_REQ_ORDER* get_appid_req = (RAIL_GET_APPID_REQ_ORDER*) event->wParam;
CopyMemory(&rail_order->get_appid_req, get_appid_req, sizeof(RAIL_GET_APPID_REQ_ORDER));
rail_send_client_get_appid_req_order(rail_order);
CopyMemory(&railOrder->get_appid_req, get_appid_req, sizeof(RAIL_GET_APPID_REQ_ORDER));
rail_send_client_get_appid_req_order(railOrder);
}
static void rail_recv_langbarinfo_event(rdpRailOrder* rail_order, wMessage* event)
static void rail_recv_langbarinfo_event(rdpRailOrder* railOrder, wMessage* event)
{
RAIL_LANGBAR_INFO_ORDER* langbar_info = (RAIL_LANGBAR_INFO_ORDER*) event->wParam;
CopyMemory(&rail_order->langbar_info, langbar_info, sizeof(RAIL_LANGBAR_INFO_ORDER));
rail_send_client_langbar_info_order(rail_order);
CopyMemory(&railOrder->langbar_info, langbar_info, sizeof(RAIL_LANGBAR_INFO_ORDER));
rail_send_client_langbar_info_order(railOrder);
}
static void rail_process_event(rdpSvcPlugin* plugin, wMessage* event)
@@ -256,6 +264,24 @@ static void rail_process_event(rdpSvcPlugin* plugin, wMessage* event)
int rail_client_execute(RailClientContext* context, RAIL_EXEC_ORDER* exec)
{
railPlugin* rail = (railPlugin*) context->handle;
char* exeOrFile;
exeOrFile = exec->RemoteApplicationProgram;
if (strlen(exeOrFile) >= 2)
{
if (strncmp(exeOrFile, "||", 2) != 0)
exec->flags |= RAIL_EXEC_FLAG_FILE;
}
rail_string_to_unicode_string(exec->RemoteApplicationProgram, &exec->exeOrFile); /* RemoteApplicationProgram */
rail_string_to_unicode_string(exec->RemoteApplicationWorkingDir, &exec->workingDir); /* ShellWorkingDirectory */
rail_string_to_unicode_string(exec->RemoteApplicationArguments, &exec->arguments); /* RemoteApplicationCmdLine */
rail_send_client_exec_order(rail, exec);
return 0;
}
@@ -269,8 +295,84 @@ int rail_get_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* syspa
return 0;
}
void rail_send_client_sysparam(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam)
{
wStream* s;
int length;
railPlugin* rail = (railPlugin*) context->handle;
length = RAIL_SYSPARAM_ORDER_LENGTH;
switch (sysparam->param)
{
case SPI_SET_DRAG_FULL_WINDOWS:
case SPI_SET_KEYBOARD_CUES:
case SPI_SET_KEYBOARD_PREF:
case SPI_SET_MOUSE_BUTTON_SWAP:
length += 1;
break;
case SPI_SET_WORK_AREA:
case SPI_DISPLAY_CHANGE:
case SPI_TASKBAR_POS:
length += 8;
break;
case SPI_SET_HIGH_CONTRAST:
length += sysparam->highContrast.colorSchemeLength + 10;
break;
}
s = rail_pdu_init(RAIL_SYSPARAM_ORDER_LENGTH + 8);
rail_write_client_sysparam_order(s, sysparam);
rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM);
Stream_Free(s, TRUE);
}
int rail_client_system_param(RailClientContext* context, RAIL_SYSPARAM_ORDER* sysparam)
{
if (sysparam->params & SPI_MASK_SET_HIGH_CONTRAST)
{
sysparam->param = SPI_SET_HIGH_CONTRAST;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_TASKBAR_POS)
{
sysparam->param = SPI_TASKBAR_POS;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_SET_MOUSE_BUTTON_SWAP)
{
sysparam->param = SPI_SET_MOUSE_BUTTON_SWAP;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_SET_KEYBOARD_PREF)
{
sysparam->param = SPI_SET_KEYBOARD_PREF;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_SET_DRAG_FULL_WINDOWS)
{
sysparam->param = SPI_SET_DRAG_FULL_WINDOWS;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_SET_KEYBOARD_CUES)
{
sysparam->param = SPI_SET_KEYBOARD_CUES;
rail_send_client_sysparam(context, sysparam);
}
if (sysparam->params & SPI_MASK_SET_WORK_AREA)
{
sysparam->param = SPI_SET_WORK_AREA;
rail_send_client_sysparam(context, sysparam);
}
return 0;
}
@@ -391,9 +493,12 @@ int VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
{
context = (RailClientContext*) malloc(sizeof(RailClientContext));
context->handle = (void*) _p;
context->ClientExecute = rail_client_execute;
context->ClientActivate = rail_client_activate;
context->GetSystemParam = rail_get_system_param;
context->ClientSystemParam = rail_client_system_param;
context->ServerSystemParam = rail_server_system_param;
context->ClientSystemCommand = rail_client_system_command;
context->ClientHandshake = rail_client_handshake;

2
channels/rail/client/rail_main.h
View File

@@ -43,6 +43,8 @@ struct rail_plugin
};
typedef struct rail_plugin railPlugin;
RailClientContext* rail_get_client_interface(void* railObject);
void rail_send_channel_event(void* rail_object, UINT16 event_type, void* param);
void rail_send_channel_data(void* rail_object, void* data, size_t length);

81
channels/rail/client/rail_orders.c
View File

@@ -31,7 +31,7 @@
#include "rail_orders.h"
void rail_send_pdu(rdpRailOrder* railOrder, wStream* s, UINT16 orderType)
void rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType)
{
UINT16 orderLength;
@@ -41,10 +41,10 @@ void rail_send_pdu(rdpRailOrder* railOrder, wStream* s, UINT16 orderType)
rail_write_pdu_header(s, orderType, orderLength);
Stream_SetPosition(s, orderLength);
WLog_Print(((railPlugin*) railOrder->plugin)->log, WLOG_DEBUG, "Sending %s PDU, length: %d",
WLog_Print(rail->log, WLOG_DEBUG, "Sending %s PDU, length: %d",
RAIL_ORDER_TYPE_STRINGS[((orderType & 0xF0) >> 3) + (orderType & 0x0F)], orderLength);
rail_send_channel_data(railOrder->plugin, Stream_Buffer(s), orderLength);
rail_send_channel_data(rail, Stream_Buffer(s), orderLength);
}
void rail_write_high_contrast(wStream* s, RAIL_HIGH_CONTRAST* highContrast)
@@ -278,6 +278,8 @@ void rail_write_langbar_info_order(wStream* s, RAIL_LANGBAR_INFO_ORDER* langbarI
BOOL rail_recv_handshake_order(rdpRailOrder* railOrder, wStream* s)
{
RailClientContext* context = rail_get_client_interface(railOrder->plugin);
if (!rail_read_handshake_order(s, &railOrder->handshake))
return FALSE;
@@ -314,30 +316,59 @@ BOOL rail_recv_handshake_order(rdpRailOrder* railOrder, wStream* s)
railOrder->sysparam.workArea.right = 1024;
railOrder->sysparam.workArea.bottom = 768;
rail_send_channel_event(railOrder->plugin,
if (context->custom)
{
RAIL_SYSPARAM_ORDER sysparam;
IFCALL(context->GetSystemParam, context, &sysparam);
}
else
{
rail_send_channel_event(railOrder->plugin,
RailChannel_GetSystemParam, &railOrder->sysparam);
}
return TRUE;
}
BOOL rail_recv_exec_result_order(rdpRailOrder* railOrder, wStream* s)
{
if (!rail_read_server_exec_result_order(s, &railOrder->exec_result))
RAIL_EXEC_RESULT_ORDER execResult;
RailClientContext* context = rail_get_client_interface(railOrder->plugin);
ZeroMemory(&execResult, sizeof(RAIL_EXEC_RESULT_ORDER));
if (!rail_read_server_exec_result_order(s, &execResult))
return FALSE;
rail_send_channel_event(railOrder->plugin,
RailChannel_ServerExecuteResult, &railOrder->exec_result);
if (context->custom)
{
IFCALL(context->ServerExecuteResult, context, &execResult);
}
else
{
rail_send_channel_event(railOrder->plugin,
RailChannel_ServerExecuteResult, &execResult);
}
return TRUE;
}
BOOL rail_recv_server_sysparam_order(rdpRailOrder* railOrder, wStream* s)
{
RailClientContext* context = rail_get_client_interface(railOrder->plugin);
if (!rail_read_server_sysparam_order(s, &railOrder->sysparam))
return FALSE;
rail_send_channel_event(railOrder->plugin,
RailChannel_ServerSystemParam, &railOrder->sysparam);
if (context->custom)
{
IFCALL(context->ServerSystemParam, context, &railOrder->sysparam);
}
else
{
rail_send_channel_event(railOrder->plugin,
RailChannel_ServerSystemParam, &railOrder->sysparam);
}
return TRUE;
}
@@ -433,7 +464,7 @@ void rail_send_handshake_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_HANDSHAKE_ORDER_LENGTH);
rail_write_handshake_order(s, &railOrder->handshake);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_HANDSHAKE);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_HANDSHAKE);
Stream_Free(s, TRUE);
}
@@ -442,23 +473,23 @@ void rail_send_client_status_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_CLIENT_STATUS_ORDER_LENGTH);
rail_write_client_status_order(s, &railOrder->client_status);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_CLIENTSTATUS);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_CLIENTSTATUS);
Stream_Free(s, TRUE);
}
void rail_send_client_exec_order(rdpRailOrder* railOrder)
void rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec)
{
wStream* s;
int length;
length = RAIL_EXEC_ORDER_LENGTH +
railOrder->exec.exeOrFile.length +
railOrder->exec.workingDir.length +
railOrder->exec.arguments.length;
exec->exeOrFile.length +
exec->workingDir.length +
exec->arguments.length;
s = rail_pdu_init(RAIL_EXEC_ORDER_LENGTH);
rail_write_client_exec_order(s, &railOrder->exec);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_EXEC);
rail_write_client_exec_order(s, exec);
rail_send_pdu(rail, s, RDP_RAIL_ORDER_EXEC);
Stream_Free(s, TRUE);
}
@@ -491,7 +522,7 @@ void rail_send_client_sysparam_order(rdpRailOrder* railOrder)
s = rail_pdu_init(RAIL_SYSPARAM_ORDER_LENGTH + 8);
rail_write_client_sysparam_order(s, &railOrder->sysparam);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_SYSPARAM);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSPARAM);
Stream_Free(s, TRUE);
}
@@ -545,7 +576,7 @@ void rail_send_client_activate_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_ACTIVATE_ORDER_LENGTH);
rail_write_client_activate_order(s, &railOrder->activate);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_ACTIVATE);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_ACTIVATE);
Stream_Free(s, TRUE);
}
@@ -554,7 +585,7 @@ void rail_send_client_sysmenu_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_SYSMENU_ORDER_LENGTH);
rail_write_client_sysmenu_order(s, &railOrder->sysmenu);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_SYSMENU);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSMENU);
Stream_Free(s, TRUE);
}
@@ -563,7 +594,7 @@ void rail_send_client_syscommand_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_SYSCOMMAND_ORDER_LENGTH);
rail_write_client_syscommand_order(s, &railOrder->syscommand);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_SYSCOMMAND);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSCOMMAND);
Stream_Free(s, TRUE);
}
@@ -572,7 +603,7 @@ void rail_send_client_notify_event_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_NOTIFY_EVENT_ORDER_LENGTH);
rail_write_client_notify_event_order(s, &railOrder->notify_event);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_NOTIFY_EVENT);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_NOTIFY_EVENT);
Stream_Free(s, TRUE);
}
@@ -581,7 +612,7 @@ void rail_send_client_window_move_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_WINDOW_MOVE_ORDER_LENGTH);
rail_write_client_window_move_order(s, &railOrder->window_move);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_WINDOWMOVE);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_WINDOWMOVE);
Stream_Free(s, TRUE);
}
@@ -590,7 +621,7 @@ void rail_send_client_get_appid_req_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_GET_APPID_REQ_ORDER_LENGTH);
rail_write_client_get_appid_req_order(s, &railOrder->get_appid_req);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_GET_APPID_REQ);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_GET_APPID_REQ);
Stream_Free(s, TRUE);
}
@@ -599,7 +630,7 @@ void rail_send_client_langbar_info_order(rdpRailOrder* railOrder)
wStream* s;
s = rail_pdu_init(RAIL_LANGBAR_INFO_ORDER_LENGTH);
rail_write_langbar_info_order(s, &railOrder->langbar_info);
rail_send_pdu(railOrder, s, RDP_RAIL_ORDER_LANGBARINFO);
rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_LANGBARINFO);
Stream_Free(s, TRUE);
}

30
channels/rail/client/rail_orders.h
View File

@@ -41,22 +41,24 @@ 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(rdpRailOrder* rail_order, wStream* s);
BOOL rail_order_recv(rdpRailOrder* railOrder, wStream* s);
void rail_send_handshake_order(rdpRailOrder* rail_order);
void rail_send_client_status_order(rdpRailOrder* rail_order);
void rail_send_client_exec_order(rdpRailOrder* rail_order);
void rail_send_client_sysparam_order(rdpRailOrder* rail_order);
void rail_send_client_sysparams_order(rdpRailOrder* rail_order);
void rail_send_client_activate_order(rdpRailOrder* rail_order);
void rail_send_client_sysmenu_order(rdpRailOrder* rail_order);
void rail_send_client_syscommand_order(rdpRailOrder* rail_order);
void rail_send_client_notify_event_order(rdpRailOrder* rail_order);
void rail_send_client_window_move_order(rdpRailOrder* rail_order);
void rail_send_client_get_appid_req_order(rdpRailOrder* rail_order);
void rail_send_client_langbar_info_order(rdpRailOrder* rail_order);
void rail_send_pdu(railPlugin* rail, wStream* s, UINT16 orderType);
void rail_send_handshake_order(rdpRailOrder* railOrder);
void rail_send_client_status_order(rdpRailOrder* railOrder);
void rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec);
void rail_send_client_sysparam_order(rdpRailOrder* railOrder);
void rail_send_client_sysparams_order(rdpRailOrder* railOrder);
void rail_send_client_activate_order(rdpRailOrder* railOrder);
void rail_send_client_sysmenu_order(rdpRailOrder* railOrder);
void rail_send_client_syscommand_order(rdpRailOrder* railOrder);
void rail_send_client_notify_event_order(rdpRailOrder* railOrder);
void rail_send_client_window_move_order(rdpRailOrder* railOrder);
void rail_send_client_get_appid_req_order(rdpRailOrder* railOrder);
void rail_send_client_langbar_info_order(rdpRailOrder* railOrder);
rdpRailOrder* rail_order_new(void);
void rail_order_free(rdpRailOrder* rail_order);
void rail_order_free(rdpRailOrder* railOrder);
#endif /* __RAIL_ORDERS_H */

2
include/freerdp/client/rail.h
View File

@@ -31,7 +31,7 @@
* Client Interface
*/
#define RAIL_SVC_CHANNEL_NAME "RAIL"
#define RAIL_SVC_CHANNEL_NAME "rail"
typedef struct _rail_client_context RailClientContext;

3
include/freerdp/rail.h
View File

@@ -223,6 +223,9 @@ struct _RAIL_EXEC_ORDER
RAIL_UNICODE_STRING exeOrFile;
RAIL_UNICODE_STRING workingDir;
RAIL_UNICODE_STRING arguments;
char* RemoteApplicationProgram;
char* RemoteApplicationWorkingDir;
char* RemoteApplicationArguments;
};
typedef struct _RAIL_EXEC_ORDER RAIL_EXEC_ORDER;