channel/rail: add initial handling all RAIL PDU from server.

Note:
Sometimes we have multi-thread side effect with data trasfer throught shared
memory between different threads.

diff --git a/channels/rail/rail_orders.c b/channels/rail/rail_orders.c
index 5e38bf4..d6fad31 100644 (file)
--- a/channels/rail/rail_orders.c
+++ b/channels/rail/rail_orders.c
@@ -148,11 +148,11 @@ void rail_read_server_sysparam_order(STREAM* s, RAIL_SYSPARAM_ORDER* sysparam)
        switch (sysparam->param)
        {
                case SPI_SET_SCREEN_SAVE_ACTIVE:
-                       sysparam->set_screen_save_active = (body != 0) ? True : False;
+                       sysparam->setScreenSaveActive = (body != 0) ? True : False;
                        break;
 
                case SPI_SET_SCREEN_SAVE_SECURE:
-                       sysparam->set_screen_save_secure = (body != 0) ? True : False;
+                       sysparam->setScreenSaveSecure = (body != 0) ? True : False;
                        break;
 
                default:
@@ -352,14 +352,49 @@ void rail_recv_handshake_order(rdpRailOrder* rail_order, STREAM* s)
        rail_order->sysparam.workArea.bottom = 768;
 
        rail_send_channel_event(rail_order->plugin,
-               RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS, (void*) &rail_order->sysparam);
+               RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS, &rail_order->sysparam);
 }
 
 void rail_recv_exec_result_order(rdpRailOrder* rail_order, STREAM* s)
 {
        rail_read_server_exec_result_order(s, &rail_order->exec_result);
        rail_send_channel_event(rail_order->plugin,
-               RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS, (void*) &rail_order->exec_result);
+               RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS, &rail_order->exec_result);
+}
+
+void rail_recv_server_sysparam_order(rdpRailOrder* rail_order, STREAM* s)
+{
+       rail_read_server_sysparam_order(s, &rail_order->sysparam);
+       rail_send_channel_event(rail_order->plugin,
+               RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM, &rail_order->sysparam);
+}
+
+void rail_recv_server_minmaxinfo_order(rdpRailOrder* rail_order, STREAM* s)
+{
+       rail_read_server_minmaxinfo_order(s, &rail_order->minmaxinfo);
+       rail_send_channel_event(rail_order->plugin,
+               RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO, &rail_order->minmaxinfo);
+}
+
+void rail_recv_server_localmovesize_order(rdpRailOrder* rail_order, STREAM* s)
+{
+       rail_read_server_localmovesize_order(s, &rail_order->localmovesize);
+       rail_send_channel_event(rail_order->plugin,
+               RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE, &rail_order->localmovesize);
+}
+
+void rail_recv_server_get_appid_resp_order(rdpRailOrder* rail_order, STREAM* s)
+{
+       rail_read_server_get_appid_resp_order(s, &rail_order->get_appid_resp);
+       rail_send_channel_event(rail_order->plugin,
+               RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP, &rail_order->get_appid_resp);
+}
+
+void rail_recv_langbar_info_order(rdpRailOrder* rail_order, STREAM* s)
+{
+       rail_read_langbar_info_order(s, &rail_order->langbar_info);
+       rail_send_channel_event(rail_order->plugin,
+               RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO, &rail_order->langbar_info);
 }
 
 void rail_order_recv(rdpRailOrder* rail_order, STREAM* s)
@@ -383,26 +418,27 @@ void rail_order_recv(rdpRailOrder* rail_order, STREAM* s)
                        break;
 
                case RDP_RAIL_ORDER_SYSPARAM:
-                       rail_read_server_sysparam_order(s, &rail_order->sysparam);
+                       rail_recv_server_sysparam_order(rail_order, s);
                        break;
 
                case RDP_RAIL_ORDER_MINMAXINFO:
-                       rail_read_server_minmaxinfo_order(s, &rail_order->minmaxinfo);
+                       rail_recv_server_minmaxinfo_order(rail_order, s);
                        break;
 
                case RDP_RAIL_ORDER_LOCALMOVESIZE:
-                       rail_read_server_localmovesize_order(s, &rail_order->localmovesize);
+                       rail_recv_server_localmovesize_order(rail_order, s);
                        break;
 
                case RDP_RAIL_ORDER_GET_APPID_RESP:
-                       rail_read_server_get_appid_resp_order(s, &rail_order->get_appid_resp);
+                       rail_recv_server_get_appid_resp_order(rail_order, s);
                        break;
 
                case RDP_RAIL_ORDER_LANGBARINFO:
-                       rail_read_langbar_info_order(s, &rail_order->langbar_info);
+                       rail_recv_langbar_info_order(rail_order, s);
                        break;
 
                default:
+                       printf("Unknown RAIL PDU order reveived.");
                        break;
        }
 }

diff --git a/client/X11/xf_rail.c b/client/X11/xf_rail.c
index cd8abf6..3eea78e 100644 (file)
--- a/client/X11/xf_rail.c
+++ b/client/X11/xf_rail.c
@@ -18,9 +18,11 @@
  */
 
 #include <freerdp/utils/event.h>
+#include <freerdp/utils/hexdump.h>
 #include <freerdp/rail/rail.h>
-#include "xf_window.h"
 
+
+#include "xf_window.h"
 #include "xf_rail.h"
 
 void xf_rail_paint(xfInfo* xfi, rdpRail* rail, uint32 ileft, uint32 itop, uint32 iright, uint32 ibottom)
@@ -165,6 +167,92 @@ void xf_process_rail_exec_result_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVE
        }
 }
 
+void xf_process_rail_server_sysparam_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
+{
+       RAIL_SYSPARAM_ORDER* sysparam = (RAIL_SYSPARAM_ORDER*)event->user_data;
+
+       switch (sysparam->param)
+       {
+       case SPI_SET_SCREEN_SAVE_ACTIVE:
+               printf("xf_process_rail_server_sysparam_event: Server System Param PDU: setScreenSaveActive=%d\n", sysparam->setScreenSaveActive);
+               break;
+       case SPI_SET_SCREEN_SAVE_SECURE:
+               printf("xf_process_rail_server_sysparam_event: Server System Param PDU: setScreenSaveSecure=%d\n", sysparam->setScreenSaveSecure);
+               break;
+       }
+}
+
+void xf_process_rail_server_minmaxinfo_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
+{
+       RAIL_MINMAXINFO_ORDER* minmax = (RAIL_MINMAXINFO_ORDER*)event->user_data;
+
+       printf("Server Min Max Info PDU: windowId=0x%X "
+               "maxWidth=%d maxHeight=%d maxPosX=%d maxPosY=%d "
+               "minTrackWidth=%d minTrackHeight=%d maxTrackWidth=%d maxTrackHeight=%d\n",
+               minmax->windowId,
+               minmax->maxWidth,
+               minmax->maxHeight,
+               minmax->maxPosX,
+               minmax->maxPosY,
+               minmax->minTrackWidth,
+               minmax->minTrackHeight,
+               minmax->maxTrackWidth,
+               minmax->maxTrackHeight
+               );
+}
+
+void xf_process_rail_server_localmovesize_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
+{
+       RAIL_LOCALMOVESIZE_ORDER* movesize = (RAIL_LOCALMOVESIZE_ORDER*)event->user_data;
+       const char* movetype_names[] =
+       {
+       "(invalid)",
+       "RAIL_WMSZ_LEFT",
+       "RAIL_WMSZ_RIGHT",
+       "RAIL_WMSZ_TOP",
+       "RAIL_WMSZ_TOPLEFT",
+       "RAIL_WMSZ_TOPRIGHT",
+       "RAIL_WMSZ_BOTTOM",
+       "RAIL_WMSZ_BOTTOMLEFT",
+       "RAIL_WMSZ_BOTTOMRIGHT",
+       "RAIL_WMSZ_MOVE",
+       "RAIL_WMSZ_KEYMOVE",
+       "RAIL_WMSZ_KEYSIZE",
+       };
+
+       printf("Server Local MoveSize PDU: windowId=0x%X "
+               "isMoveSizeStart=%d moveSizeType=%s PosX=%d PosY=%d\n",
+               movesize->windowId,
+               movesize->isMoveSizeStart,
+               movetype_names[movesize->moveSizeType],
+               movesize->posX,
+               movesize->posY
+               );
+}
+
+void xf_process_rail_appid_resp_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
+{
+       RAIL_GET_APPID_RESP_ORDER* appid_resp =
+               (RAIL_GET_APPID_RESP_ORDER*)event->user_data;
+
+       printf("Server Application ID Response PDU: windowId=0x%X "
+               "applicationId=(length=%d dump)\n",
+               appid_resp->windowId,
+               appid_resp->applicationId.length
+               );
+       freerdp_hexdump(appid_resp->applicationId.string, appid_resp->applicationId.length);
+}
+
+void xf_process_rail_langbarinfo_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
+{
+       RAIL_LANGBAR_INFO_ORDER* langbar =
+               (RAIL_LANGBAR_INFO_ORDER*)event->user_data;
+
+       printf("Language Bar Information PDU: languageBarStatus=0x%X\n",
+               langbar->languageBarStatus
+               );
+}
+
 void xf_process_rail_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
 {
        switch (event->event_type)
@@ -177,6 +265,26 @@ void xf_process_rail_event(xfInfo* xfi, rdpChanMan* chanman, RDP_EVENT* event)
                        xf_process_rail_exec_result_event(xfi, chanman, event);
                        break;
 
+               case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM:
+                       xf_process_rail_server_sysparam_event(xfi, chanman, event);
+                       break;
+
+               case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO:
+                       xf_process_rail_server_minmaxinfo_event(xfi, chanman, event);
+                       break;
+
+               case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE:
+                       xf_process_rail_server_localmovesize_event(xfi, chanman, event);
+                       break;
+
+               case RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP:
+                       xf_process_rail_appid_resp_event(xfi, chanman, event);
+                       break;
+
+               case RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO:
+                       xf_process_rail_langbarinfo_event(xfi, chanman, event);
+                       break;
+
                default:
                        break;
        }

diff --git a/include/freerdp/rail.h b/include/freerdp/rail.h
index 5ea48b9..745e4b3 100644 (file)
--- a/include/freerdp/rail.h
+++ b/include/freerdp/rail.h
@@ -218,8 +218,8 @@ struct _RAIL_SYSPARAM_ORDER
        RECTANGLE_16 displayChange;
        RECTANGLE_16 taskbarPos;
        HIGH_CONTRAST highContrast;
-       boolean set_screen_save_active;
-       boolean set_screen_save_secure;
+       boolean setScreenSaveActive;
+       boolean setScreenSaveSecure;
 };
 typedef struct _RAIL_SYSPARAM_ORDER RAIL_SYSPARAM_ORDER;
 
@@ -330,8 +330,21 @@ enum RDP_RAIL_PDU_TYPE
 enum RDP_EVENT_TYPE_RAIL
 {
        RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS = 1,
-       RDP_EVENT_TYPE_RAIL_CLIENT_SET_SYSPARAMS = 2,
-       RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS = 3
+       RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS,
+       RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM,
+       RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO,
+       RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE,
+       RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP,
+       RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO,
+
+       RDP_EVENT_TYPE_RAIL_CLIENT_SET_SYSPARAMS,
+       RDP_EVENT_TYPE_RAIL_CLIENT_ACTIVATE,
+       RDP_EVENT_TYPE_RAIL_CLIENT_SYSMENU,
+       RDP_EVENT_TYPE_RAIL_CLIENT_SYSCOMMAND,
+       RDP_EVENT_TYPE_RAIL_CLIENT_NOTIFY_EVENT,
+       RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE,
+       RDP_EVENT_TYPE_RAIL_CLIENT_APPID_REQ,
+       RDP_EVENT_TYPE_RAIL_CLIENT_LANGBARINFO
 };
 
 #endif /* __RAIL_GLOBAL_H */