channels/rail: refactoring

diff --git a/channels/rail/client/rail_main.c b/channels/rail/client/rail_main.c
index c7cc361..46efad1 100644 (file)
--- a/channels/rail/client/rail_main.c
+++ b/channels/rail/client/rail_main.c
@@ -132,7 +132,7 @@ static void rail_recv_set_sysparams_event(rdpRailOrder* railOrder, wMessage* eve
        sysparam = (RAIL_SYSPARAM_ORDER*) event->wParam;
        memmove(&railOrder->sysparam, sysparam, sizeof(RAIL_SYSPARAM_ORDER));
 
-       rail_send_client_sysparams_order(railOrder);
+       rail_send_client_sysparams_order((railPlugin*) railOrder->plugin, &railOrder->sysparam);
 
        /* execute */
 
@@ -141,7 +141,7 @@ static void rail_recv_set_sysparams_event(rdpRailOrder* railOrder, wMessage* eve
        rail_process_addin_args(railOrder, railOrder->settings);
 }
 
-static void rail_recv_exec_remote_app_event(rdpRailOrder* rail_order, wMessage* event)
+static void rail_recv_exec_remote_app_event(rdpRailOrder* railOrder, wMessage* event)
 {
        /**
         * TODO: replace event system by an API to allow the execution
@@ -149,7 +149,7 @@ static void rail_recv_exec_remote_app_event(rdpRailOrder* rail_order, wMessage*
         * always built-in, so clients can safely link to it.
         */
 
-       //rail_process_addin_args(rail_order, data);
+       //rail_process_addin_args((railPlugin*) railOrder->plugin, data);
 }
 
 static void rail_recv_activate_event(rdpRailOrder* railOrder, wMessage* event)
@@ -157,15 +157,15 @@ static void rail_recv_activate_event(rdpRailOrder* railOrder, wMessage* event)
        RAIL_ACTIVATE_ORDER* activate = (RAIL_ACTIVATE_ORDER*) event->wParam;
 
        CopyMemory(&railOrder->activate, activate, sizeof(RAIL_ACTIVATE_ORDER));
-       rail_send_client_activate_order(railOrder);
+       rail_send_client_activate_order((railPlugin*) railOrder->plugin, &railOrder->activate);
 }
 
-static void rail_recv_sysmenu_event(rdpRailOrder* rail_order, wMessage* event)
+static void rail_recv_sysmenu_event(rdpRailOrder* railOrder, wMessage* event)
 {
        RAIL_SYSMENU_ORDER* sysmenu = (RAIL_SYSMENU_ORDER*) event->wParam;
 
-       CopyMemory(&rail_order->sysmenu, sysmenu, sizeof(RAIL_SYSMENU_ORDER));
-       rail_send_client_sysmenu_order(rail_order);
+       CopyMemory(&railOrder->sysmenu, sysmenu, sizeof(RAIL_SYSMENU_ORDER));
+       rail_send_client_sysmenu_order((railPlugin*) railOrder->plugin, &railOrder->sysmenu);
 }
 
 static void rail_recv_syscommand_event(rdpRailOrder* railOrder, wMessage* event)
@@ -173,7 +173,7 @@ static void rail_recv_syscommand_event(rdpRailOrder* railOrder, wMessage* event)
        RAIL_SYSCOMMAND_ORDER* syscommand = (RAIL_SYSCOMMAND_ORDER*) event->wParam;
 
        CopyMemory(&railOrder->syscommand, syscommand, sizeof(RAIL_SYSCOMMAND_ORDER));
-       rail_send_client_syscommand_order(railOrder);
+       rail_send_client_syscommand_order((railPlugin*) railOrder->plugin, &railOrder->syscommand);
 }
 
 static void rail_recv_notify_event(rdpRailOrder* railOrder, wMessage* event)
@@ -181,15 +181,14 @@ static void rail_recv_notify_event(rdpRailOrder* railOrder, wMessage* event)
        RAIL_NOTIFY_EVENT_ORDER* notify = (RAIL_NOTIFY_EVENT_ORDER*) event->wParam;
 
        CopyMemory(&railOrder->notify_event, notify, sizeof(RAIL_NOTIFY_EVENT_ORDER));
-       rail_send_client_notify_event_order(railOrder);
+       rail_send_client_notify_event_order((railPlugin*) railOrder->plugin, &railOrder->notify_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(&railOrder->window_move, window_move, sizeof(RAIL_WINDOW_MOVE_ORDER));
-       rail_send_client_window_move_order(railOrder);
+       rail_send_client_window_move_order((railPlugin*) railOrder->plugin, &railOrder->window_move);
 }
 
 static void rail_recv_app_req_event(rdpRailOrder* railOrder, wMessage* event)
@@ -197,7 +196,7 @@ 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(&railOrder->get_appid_req, get_appid_req, sizeof(RAIL_GET_APPID_REQ_ORDER));
-       rail_send_client_get_appid_req_order(railOrder);
+       rail_send_client_get_appid_req_order((railPlugin*) railOrder->plugin, &railOrder->get_appid_req);
 }
 
 static void rail_recv_langbarinfo_event(rdpRailOrder* railOrder, wMessage* event)
@@ -205,7 +204,7 @@ static void rail_recv_langbarinfo_event(rdpRailOrder* railOrder, wMessage* event
        RAIL_LANGBAR_INFO_ORDER* langbar_info = (RAIL_LANGBAR_INFO_ORDER*) event->wParam;
 
        CopyMemory(&railOrder->langbar_info, langbar_info, sizeof(RAIL_LANGBAR_INFO_ORDER));
-       rail_send_client_langbar_info_order(railOrder);
+       rail_send_client_langbar_info_order((railPlugin*) railOrder->plugin, &railOrder->langbar_info);
 }
 
 static void rail_process_event(rdpSvcPlugin* plugin, wMessage* event)

diff --git a/channels/rail/client/rail_orders.c b/channels/rail/client/rail_orders.c
index 899b933..5424ba2 100644 (file)
--- a/channels/rail/client/rail_orders.c
+++ b/channels/rail/client/rail_orders.c
@@ -284,10 +284,10 @@ BOOL rail_recv_handshake_order(rdpRailOrder* railOrder, wStream* s)
                return FALSE;
 
        railOrder->handshake.buildNumber = 0x00001DB0;
-       rail_send_handshake_order(railOrder);
+       rail_send_handshake_order(railOrder->plugin, &railOrder->handshake);
 
        railOrder->client_status.flags = RAIL_CLIENTSTATUS_ALLOWLOCALMOVESIZE;
-       rail_send_client_status_order(railOrder);
+       rail_send_client_status_order(railOrder->plugin, &railOrder->client_status);
 
        /* sysparam update */
 
@@ -459,21 +459,21 @@ BOOL rail_order_recv(rdpRailOrder* railOrder, wStream* s)
        return TRUE;
 }
 
-void rail_send_handshake_order(rdpRailOrder* railOrder)
+void rail_send_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_HANDSHAKE_ORDER_LENGTH);
-       rail_write_handshake_order(s, &railOrder->handshake);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_HANDSHAKE);
+       rail_write_handshake_order(s, handshake);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_HANDSHAKE);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_status_order(rdpRailOrder* railOrder)
+void rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_CLIENT_STATUS_ORDER_LENGTH);
-       rail_write_client_status_order(s, &railOrder->client_status);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_CLIENTSTATUS);
+       rail_write_client_status_order(s, clientStatus);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_CLIENTSTATUS);
        Stream_Free(s, TRUE);
 }
 
@@ -493,14 +493,14 @@ void rail_send_client_exec_order(railPlugin* rail, RAIL_EXEC_ORDER* exec)
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_sysparam_order(rdpRailOrder* railOrder)
+void rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam)
 {
        wStream* s;
        int length;
 
        length = RAIL_SYSPARAM_ORDER_LENGTH;
 
-       switch (railOrder->sysparam.param)
+       switch (sysparam->param)
        {
                case SPI_SET_DRAG_FULL_WINDOWS:
                case SPI_SET_KEYBOARD_CUES:
@@ -516,121 +516,121 @@ void rail_send_client_sysparam_order(rdpRailOrder* railOrder)
                        break;
 
                case SPI_SET_HIGH_CONTRAST:
-                       length += railOrder->sysparam.highContrast.colorSchemeLength + 10;
+                       length += sysparam->highContrast.colorSchemeLength + 10;
                        break;
        }
 
        s = rail_pdu_init(RAIL_SYSPARAM_ORDER_LENGTH + 8);
-       rail_write_client_sysparam_order(s, &railOrder->sysparam);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSPARAM);
+       rail_write_client_sysparam_order(s, sysparam);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSPARAM);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_sysparams_order(rdpRailOrder* railOrder)
+void rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam)
 {
-       if (railOrder->sysparam.params & SPI_MASK_SET_HIGH_CONTRAST)
+       if (sysparam->params & SPI_MASK_SET_HIGH_CONTRAST)
        {
-               railOrder->sysparam.param = SPI_SET_HIGH_CONTRAST;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_HIGH_CONTRAST;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_TASKBAR_POS)
+       if (sysparam->params & SPI_MASK_TASKBAR_POS)
        {
-               railOrder->sysparam.param = SPI_TASKBAR_POS;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_TASKBAR_POS;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_SET_MOUSE_BUTTON_SWAP)
+       if (sysparam->params & SPI_MASK_SET_MOUSE_BUTTON_SWAP)
        {
-               railOrder->sysparam.param = SPI_SET_MOUSE_BUTTON_SWAP;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_MOUSE_BUTTON_SWAP;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_SET_KEYBOARD_PREF)
+       if (sysparam->params & SPI_MASK_SET_KEYBOARD_PREF)
        {
-               railOrder->sysparam.param = SPI_SET_KEYBOARD_PREF;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_KEYBOARD_PREF;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_SET_DRAG_FULL_WINDOWS)
+       if (sysparam->params & SPI_MASK_SET_DRAG_FULL_WINDOWS)
        {
-               railOrder->sysparam.param = SPI_SET_DRAG_FULL_WINDOWS;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_DRAG_FULL_WINDOWS;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_SET_KEYBOARD_CUES)
+       if (sysparam->params & SPI_MASK_SET_KEYBOARD_CUES)
        {
-               railOrder->sysparam.param = SPI_SET_KEYBOARD_CUES;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_KEYBOARD_CUES;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 
-       if (railOrder->sysparam.params & SPI_MASK_SET_WORK_AREA)
+       if (sysparam->params & SPI_MASK_SET_WORK_AREA)
        {
-               railOrder->sysparam.param = SPI_SET_WORK_AREA;
-               rail_send_client_sysparam_order(railOrder);
+               sysparam->param = SPI_SET_WORK_AREA;
+               rail_send_client_sysparam_order(rail, sysparam);
        }
 }
 
-void rail_send_client_activate_order(rdpRailOrder* railOrder)
+void rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_ACTIVATE_ORDER_LENGTH);
-       rail_write_client_activate_order(s, &railOrder->activate);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_ACTIVATE);
+       rail_write_client_activate_order(s, activate);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_ACTIVATE);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_sysmenu_order(rdpRailOrder* railOrder)
+void rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_SYSMENU_ORDER_LENGTH);
-       rail_write_client_sysmenu_order(s, &railOrder->sysmenu);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSMENU);
+       rail_write_client_sysmenu_order(s, sysmenu);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSMENU);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_syscommand_order(rdpRailOrder* railOrder)
+void rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_SYSCOMMAND_ORDER_LENGTH);
-       rail_write_client_syscommand_order(s, &railOrder->syscommand);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_SYSCOMMAND);
+       rail_write_client_syscommand_order(s, syscommand);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_SYSCOMMAND);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_notify_event_order(rdpRailOrder* railOrder)
+void rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_NOTIFY_EVENT_ORDER_LENGTH);
-       rail_write_client_notify_event_order(s, &railOrder->notify_event);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_NOTIFY_EVENT);
+       rail_write_client_notify_event_order(s, notifyEvent);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_NOTIFY_EVENT);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_window_move_order(rdpRailOrder* railOrder)
+void rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_WINDOW_MOVE_ORDER_LENGTH);
-       rail_write_client_window_move_order(s, &railOrder->window_move);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_WINDOWMOVE);
+       rail_write_client_window_move_order(s, windowMove);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_WINDOWMOVE);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_get_appid_req_order(rdpRailOrder* railOrder)
+void rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq)
 {
        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((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_GET_APPID_REQ);
+       rail_write_client_get_appid_req_order(s, getAppIdReq);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_GET_APPID_REQ);
        Stream_Free(s, TRUE);
 }
 
-void rail_send_client_langbar_info_order(rdpRailOrder* railOrder)
+void rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo)
 {
        wStream* s;
        s = rail_pdu_init(RAIL_LANGBAR_INFO_ORDER_LENGTH);
-       rail_write_langbar_info_order(s, &railOrder->langbar_info);
-       rail_send_pdu((railPlugin*) railOrder->plugin, s, RDP_RAIL_ORDER_LANGBARINFO);
+       rail_write_langbar_info_order(s, langBarInfo);
+       rail_send_pdu(rail, s, RDP_RAIL_ORDER_LANGBARINFO);
        Stream_Free(s, TRUE);
 }
 

diff --git a/channels/rail/client/rail_orders.h b/channels/rail/client/rail_orders.h
index e43d89d..55a22c0 100644 (file)
--- a/channels/rail/client/rail_orders.h
+++ b/channels/rail/client/rail_orders.h
@@ -45,18 +45,18 @@ BOOL rail_order_recv(rdpRailOrder* railOrder, wStream* s);
 
 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_handshake_order(railPlugin* rail, RAIL_HANDSHAKE_ORDER* handshake);
+void rail_send_client_status_order(railPlugin* rail, RAIL_CLIENT_STATUS_ORDER* clientStatus);
 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);
+void rail_send_client_sysparam_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam);
+void rail_send_client_sysparams_order(railPlugin* rail, RAIL_SYSPARAM_ORDER* sysparam);
+void rail_send_client_activate_order(railPlugin* rail, RAIL_ACTIVATE_ORDER* activate);
+void rail_send_client_sysmenu_order(railPlugin* rail, RAIL_SYSMENU_ORDER* sysmenu);
+void rail_send_client_syscommand_order(railPlugin* rail, RAIL_SYSCOMMAND_ORDER* syscommand);
+void rail_send_client_notify_event_order(railPlugin* rail, RAIL_NOTIFY_EVENT_ORDER* notifyEvent);
+void rail_send_client_window_move_order(railPlugin* rail, RAIL_WINDOW_MOVE_ORDER* windowMove);
+void rail_send_client_get_appid_req_order(railPlugin* rail, RAIL_GET_APPID_REQ_ORDER* getAppIdReq);
+void rail_send_client_langbar_info_order(railPlugin* rail, RAIL_LANGBAR_INFO_ORDER* langBarInfo);
 
 rdpRailOrder* rail_order_new(void);
 void rail_order_free(rdpRailOrder* railOrder);