Rename functions.

diff --git a/libfreerdp-core/activation.c b/libfreerdp-core/activation.c
index 510f748..a3b4520 100644 (file)
--- a/libfreerdp-core/activation.c
+++ b/libfreerdp-core/activation.c
@@ -34,7 +34,7 @@ void rdp_write_synchronize_pdu(STREAM* s, rdpSettings* settings)
        stream_write_uint16(s, settings->pdu_source); /* targetUser (2 bytes) */
 }
 
-boolean rdp_read_server_synchronize_pdu(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_server_synchronize_pdu(rdpRdp* rdp, STREAM* s)
 {
        return True;
 }
@@ -52,7 +52,7 @@ boolean rdp_send_server_synchronize_pdu(rdpRdp* rdp)
        return True;
 }
 
-boolean rdp_read_client_synchronize_pdu(STREAM* s)
+boolean rdp_recv_client_synchronize_pdu(STREAM* s)
 {
        uint16 messageType;
 
@@ -78,7 +78,7 @@ boolean rdp_send_client_synchronize_pdu(rdpRdp* rdp)
        return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->user_id);
 }
 
-boolean rdp_read_control_pdu(STREAM* s, uint16* action)
+boolean rdp_recv_control_pdu(STREAM* s, uint16* action)
 {
        if (stream_get_left(s) < 8)
                return False;
@@ -97,11 +97,11 @@ void rdp_write_client_control_pdu(STREAM* s, uint16 action)
        stream_write_uint32(s, 0); /* controlId (4 bytes) */
 }
 
-boolean rdp_read_server_control_pdu(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_server_control_pdu(rdpRdp* rdp, STREAM* s)
 {
        uint16 action;
 
-       rdp_read_control_pdu(s, &action);
+       rdp_recv_control_pdu(s, &action);
 
        return True;
 }
@@ -183,7 +183,7 @@ boolean rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp)
        return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST, rdp->mcs->user_id);
 }
 
-boolean rdp_read_client_font_list_pdu(STREAM* s)
+boolean rdp_recv_client_font_list_pdu(STREAM* s)
 {
        if (stream_get_left(s) < 8)
                return False;
@@ -210,7 +210,7 @@ boolean rdp_send_client_font_list_pdu(rdpRdp* rdp, uint16 flags)
        return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_LIST, rdp->mcs->user_id);
 }
 
-boolean rdp_read_server_font_map_pdu(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_server_font_map_pdu(rdpRdp* rdp, STREAM* s)
 {
        return True;
 }
@@ -231,7 +231,7 @@ boolean rdp_send_server_font_map_pdu(rdpRdp* rdp)
        return True;
 }
 
-boolean rdp_read_deactivate_all(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_deactivate_all(rdpRdp* rdp, STREAM* s)
 {
        uint16 lengthSourceDescriptor;
 
@@ -250,7 +250,7 @@ boolean rdp_server_accept_client_control_pdu(rdpRdp* rdp, STREAM* s)
 {
        uint16 action;
 
-       if (!rdp_read_control_pdu(s, &action))
+       if (!rdp_recv_control_pdu(s, &action))
                return False;
        if (action == CTRLACTION_REQUEST_CONTROL)
        {
@@ -262,7 +262,7 @@ boolean rdp_server_accept_client_control_pdu(rdpRdp* rdp, STREAM* s)
 
 boolean rdp_server_accept_client_font_list_pdu(rdpRdp* rdp, STREAM* s)
 {
-       if (!rdp_read_client_font_list_pdu(s))
+       if (!rdp_recv_client_font_list_pdu(s))
                return False;
        if (!rdp_send_server_font_map_pdu(rdp))
                return False;

diff --git a/libfreerdp-core/activation.h b/libfreerdp-core/activation.h
index a9035a1..be26d4c 100644 (file)
--- a/libfreerdp-core/activation.h
+++ b/libfreerdp-core/activation.h
@@ -38,21 +38,21 @@
 #define FONTLIST_FIRST                 0x0001
 #define FONTLIST_LAST                  0x0002
 
-boolean rdp_read_deactivate_all(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_deactivate_all(rdpRdp* rdp, STREAM* s);
 
-boolean rdp_read_server_synchronize_pdu(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_server_synchronize_pdu(rdpRdp* rdp, STREAM* s);
 boolean rdp_send_server_synchronize_pdu(rdpRdp* rdp);
-boolean rdp_read_client_synchronize_pdu(STREAM* s);
+boolean rdp_recv_client_synchronize_pdu(STREAM* s);
 boolean rdp_send_client_synchronize_pdu(rdpRdp* rdp);
-boolean rdp_read_control_pdu(STREAM* s, uint16* action);
-boolean rdp_read_server_control_pdu(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_control_pdu(STREAM* s, uint16* action);
+boolean rdp_recv_server_control_pdu(rdpRdp* rdp, STREAM* s);
 boolean rdp_send_server_control_cooperate_pdu(rdpRdp* rdp);
 boolean rdp_send_server_control_granted_pdu(rdpRdp* rdp);
 boolean rdp_send_client_control_pdu(rdpRdp* rdp, uint16 action);
 boolean rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp);
-boolean rdp_read_client_font_list_pdu(STREAM* s);
+boolean rdp_recv_client_font_list_pdu(STREAM* s);
 boolean rdp_send_client_font_list_pdu(rdpRdp* rdp, uint16 flags);
-boolean rdp_read_server_font_map_pdu(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_server_font_map_pdu(rdpRdp* rdp, STREAM* s);
 boolean rdp_send_server_font_map_pdu(rdpRdp* rdp);
 
 boolean rdp_server_accept_client_control_pdu(rdpRdp* rdp, STREAM* s);

diff --git a/libfreerdp-core/connection.c b/libfreerdp-core/connection.c
index a864180..3a5dab6 100644 (file)
--- a/libfreerdp-core/connection.c
+++ b/libfreerdp-core/connection.c
@@ -391,7 +391,7 @@ boolean rdp_server_accept_mcs_channel_join_request(rdpRdp* rdp, STREAM* s)
 
 boolean rdp_server_accept_client_info(rdpRdp* rdp, STREAM* s)
 {
-       if (!rdp_read_client_info(rdp, s))
+       if (!rdp_recv_client_info(rdp, s))
                return False;
 
        if (!license_send_valid_client_error_packet(rdp->license))

diff --git a/libfreerdp-core/fastpath.c b/libfreerdp-core/fastpath.c
index c06bab4..12b1cec 100644 (file)
--- a/libfreerdp-core/fastpath.c
+++ b/libfreerdp-core/fastpath.c
@@ -67,6 +67,18 @@ uint16 fastpath_read_header(rdpFastPath* fastpath, STREAM* s)
        return length;
 }
 
+boolean fastpath_read_security_header(rdpFastPath* fastpath, STREAM* s)
+{
+       /* TODO: fipsInformation */
+
+       if ((fastpath->encryptionFlags & FASTPATH_OUTPUT_ENCRYPTED))
+       {
+               stream_seek(s, 8); /* dataSignature */
+       }
+
+       return True;
+}
+
 static int fastpath_recv_update_surfcmd_surface_bits(rdpFastPath* fastpath, STREAM* s)
 {
        rdpUpdate* update = fastpath->rdp->update;
@@ -278,7 +290,7 @@ static void fastpath_recv_update_data(rdpFastPath* fastpath, STREAM* s)
        stream_set_pos(s, next_pos);
 }
 
-void fastpath_recv_updates(rdpFastPath* fastpath, STREAM* s)
+boolean fastpath_recv_updates(rdpFastPath* fastpath, STREAM* s)
 {
        rdpUpdate* update = fastpath->rdp->update;
 
@@ -290,6 +302,13 @@ void fastpath_recv_updates(rdpFastPath* fastpath, STREAM* s)
        }
 
        IFCALL(update->EndPaint, update);
+
+       return True;
+}
+
+boolean fastpath_recv_input(rdpFastPath* fastpath, STREAM* s)
+{
+       return True;
 }
 
 STREAM* fastpath_pdu_init(rdpFastPath* fastpath)

diff --git a/libfreerdp-core/fastpath.h b/libfreerdp-core/fastpath.h
index c1df080..bf181ff 100644 (file)
--- a/libfreerdp-core/fastpath.h
+++ b/libfreerdp-core/fastpath.h
@@ -80,7 +80,9 @@ struct rdp_fastpath
 };
 
 uint16 fastpath_read_header(rdpFastPath* fastpath, STREAM* s);
-void fastpath_recv_updates(rdpFastPath* fastpath, STREAM* s);
+boolean fastpath_read_security_header(rdpFastPath* fastpath, STREAM* s);
+boolean fastpath_recv_updates(rdpFastPath* fastpath, STREAM* s);
+boolean fastpath_recv_input(rdpFastPath* fastpath, STREAM* s);
 
 STREAM* fastpath_pdu_init(rdpFastPath* fastpath);
 void fastpath_send_pdu(rdpFastPath* fastpath, STREAM* s, uint8 numberEvents);

diff --git a/libfreerdp-core/info.c b/libfreerdp-core/info.c
index c97ad06..61a525d 100644 (file)
--- a/libfreerdp-core/info.c
+++ b/libfreerdp-core/info.c
@@ -556,7 +556,7 @@ void rdp_write_info_packet(STREAM* s, rdpSettings* settings)
  * @param s stream
  */
 
-boolean rdp_read_client_info(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_client_info(rdpRdp* rdp, STREAM* s)
 {
        uint16 length;
        uint16 channelId;
@@ -654,7 +654,7 @@ void rdp_recv_logon_info_extended(rdpRdp* rdp, STREAM* s)
        stream_seek(s, 570); /* pad */
 }
 
-boolean rdp_read_save_session_info(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_save_session_info(rdpRdp* rdp, STREAM* s)
 {
        uint32 infoType;
 

diff --git a/libfreerdp-core/info.h b/libfreerdp-core/info.h
index 689f1c1..199fb06 100644 (file)
--- a/libfreerdp-core/info.h
+++ b/libfreerdp-core/info.h
@@ -83,8 +83,8 @@ boolean rdp_read_extended_info_packet(STREAM* s, rdpSettings* settings);
 void rdp_write_extended_info_packet(STREAM* s, rdpSettings* settings);
 boolean rdp_read_info_packet(STREAM* s, rdpSettings* settings);
 void rdp_write_info_packet(STREAM* s, rdpSettings* settings);
-boolean rdp_read_client_info(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_client_info(rdpRdp* rdp, STREAM* s);
 boolean rdp_send_client_info(rdpRdp* rdp);
-boolean rdp_read_save_session_info(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_save_session_info(rdpRdp* rdp, STREAM* s);
 
 #endif /* __INFO_H */

diff --git a/libfreerdp-core/peer.c b/libfreerdp-core/peer.c
index 2cc3c87..922a973 100644 (file)
--- a/libfreerdp-core/peer.c
+++ b/libfreerdp-core/peer.c
@@ -54,7 +54,7 @@ static boolean freerdp_peer_check_fds(freerdp_peer* client)
        return True;
 }
 
-static boolean peer_read_data_pdu(rdpPeer* peer, STREAM* s)
+static boolean peer_recv_data_pdu(rdpPeer* peer, STREAM* s)
 {
        uint8 type;
        uint16 length;
@@ -66,7 +66,7 @@ static boolean peer_read_data_pdu(rdpPeer* peer, STREAM* s)
        switch (type)
        {
                case DATA_PDU_TYPE_SYNCHRONIZE:
-                       if (!rdp_read_client_synchronize_pdu(s))
+                       if (!rdp_recv_client_synchronize_pdu(s))
                                return False;
                        break;
 
@@ -97,7 +97,7 @@ static boolean peer_read_data_pdu(rdpPeer* peer, STREAM* s)
        return True;
 }
 
-static boolean peer_read_tpkt_pdu(rdpPeer* peer, STREAM* s)
+static boolean peer_recv_tpkt_pdu(rdpPeer* peer, STREAM* s)
 {
        uint16 length;
        uint16 pduType;
@@ -122,7 +122,7 @@ static boolean peer_read_tpkt_pdu(rdpPeer* peer, STREAM* s)
                switch (pduType)
                {
                        case PDU_TYPE_DATA:
-                               if (!peer_read_data_pdu(peer, s))
+                               if (!peer_recv_data_pdu(peer, s))
                                        return False;
                                break;
 
@@ -135,18 +135,17 @@ static boolean peer_read_tpkt_pdu(rdpPeer* peer, STREAM* s)
        return True;
 }
 
-static boolean peer_read_fastpath_pdu(rdpPeer* peer, STREAM* s)
+static boolean peer_recv_fastpath_pdu(rdpPeer* peer, STREAM* s)
 {
-       printf("FastPath Input PDU\n");
        return True;
 }
 
-static boolean peer_read_pdu(rdpPeer* peer, STREAM* s)
+static boolean peer_recv_pdu(rdpPeer* peer, STREAM* s)
 {
        if (tpkt_verify_header(s))
-               return peer_read_tpkt_pdu(peer, s);
+               return peer_recv_tpkt_pdu(peer, s);
        else
-               return peer_read_fastpath_pdu(peer, s);
+               return peer_recv_fastpath_pdu(peer, s);
 }
 
 static int peer_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
@@ -191,7 +190,7 @@ static int peer_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
                        break;
 
                case CONNECTION_STATE_ACTIVE:
-                       if (!peer_read_pdu(peer, s))
+                       if (!peer_recv_pdu(peer, s))
                                return -1;
                        break;
 

diff --git a/libfreerdp-core/rdp.c b/libfreerdp-core/rdp.c
index 4710cc6..865e28e 100644 (file)
--- a/libfreerdp-core/rdp.c
+++ b/libfreerdp-core/rdp.c
@@ -288,7 +288,7 @@ boolean rdp_send_data_pdu(rdpRdp* rdp, STREAM* s, uint8 type, uint16 channel_id)
        return True;
 }
 
-void rdp_read_set_error_info_data_pdu(STREAM* s)
+void rdp_recv_set_error_info_data_pdu(STREAM* s)
 {
        uint32 errorInfo;
 
@@ -298,7 +298,7 @@ void rdp_read_set_error_info_data_pdu(STREAM* s)
                rdp_print_errinfo(errorInfo);
 }
 
-void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
+void rdp_recv_data_pdu(rdpRdp* rdp, STREAM* s)
 {
        uint8 type;
        uint16 length;
@@ -316,7 +316,7 @@ void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
                        break;
 
                case DATA_PDU_TYPE_CONTROL:
-                       rdp_read_server_control_pdu(rdp, s);
+                       rdp_recv_server_control_pdu(rdp, s);
                        break;
 
                case DATA_PDU_TYPE_POINTER:
@@ -326,7 +326,7 @@ void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
                        break;
 
                case DATA_PDU_TYPE_SYNCHRONIZE:
-                       rdp_read_server_synchronize_pdu(rdp, s);
+                       rdp_recv_server_synchronize_pdu(rdp, s);
                        break;
 
                case DATA_PDU_TYPE_REFRESH_RECT:
@@ -345,14 +345,14 @@ void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
                        break;
 
                case DATA_PDU_TYPE_SAVE_SESSION_INFO:
-                       rdp_read_save_session_info(rdp, s);
+                       rdp_recv_save_session_info(rdp, s);
                        break;
 
                case DATA_PDU_TYPE_FONT_LIST:
                        break;
 
                case DATA_PDU_TYPE_FONT_MAP:
-                       rdp_read_server_font_map_pdu(rdp, s);
+                       rdp_recv_server_font_map_pdu(rdp, s);
                        break;
 
                case DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS:
@@ -371,7 +371,7 @@ void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
                        break;
 
                case DATA_PDU_TYPE_SET_ERROR_INFO:
-                       rdp_read_set_error_info_data_pdu(s);
+                       rdp_recv_set_error_info_data_pdu(s);
                        break;
 
                case DATA_PDU_TYPE_DRAW_NINEGRID_ERROR:
@@ -400,7 +400,7 @@ void rdp_read_data_pdu(rdpRdp* rdp, STREAM* s)
  * @param s stream
  */
 
-static boolean rdp_read_tpkt_pdu(rdpRdp* rdp, STREAM* s)
+static boolean rdp_recv_tpkt_pdu(rdpRdp* rdp, STREAM* s)
 {
        uint16 length;
        uint16 pduType;
@@ -424,16 +424,16 @@ static boolean rdp_read_tpkt_pdu(rdpRdp* rdp, STREAM* s)
                switch (pduType)
                {
                        case PDU_TYPE_DATA:
-                               rdp_read_data_pdu(rdp, s);
+                               rdp_recv_data_pdu(rdp, s);
                                break;
 
                        case PDU_TYPE_DEACTIVATE_ALL:
-                               if (!rdp_read_deactivate_all(rdp, s))
+                               if (!rdp_recv_deactivate_all(rdp, s))
                                        return False;
                                break;
 
                        case PDU_TYPE_SERVER_REDIRECTION:
-                               rdp_read_enhanced_security_redirection_packet(rdp, s);
+                               rdp_recv_enhanced_security_redirection_packet(rdp, s);
                                break;
 
                        default:
@@ -445,35 +445,31 @@ static boolean rdp_read_tpkt_pdu(rdpRdp* rdp, STREAM* s)
        return True;
 }
 
-static boolean rdp_read_fastpath_pdu(rdpRdp* rdp, STREAM* s)
+static boolean rdp_recv_fastpath_pdu(rdpRdp* rdp, STREAM* s)
 {
        uint16 length;
 
        length = fastpath_read_header(rdp->fastpath, s);
-       if (length > stream_get_size(s))
+       if (length == 0 || length > stream_get_size(s))
        {
                printf("incorrect FastPath PDU header length %d\n", length);
                return False;
        }
 
-       /* TODO: fipsInformation */
-
-       if ((rdp->fastpath->encryptionFlags & FASTPATH_OUTPUT_ENCRYPTED))
-       {
-               stream_seek(s, 8); /* dataSignature */
-       }
+       if (!fastpath_read_security_header(rdp->fastpath, s))
+               return False;
 
        fastpath_recv_updates(rdp->fastpath, s);
 
        return True;
 }
 
-static boolean rdp_read_pdu(rdpRdp* rdp, STREAM* s)
+static boolean rdp_recv_pdu(rdpRdp* rdp, STREAM* s)
 {
        if (tpkt_verify_header(s))
-               return rdp_read_tpkt_pdu(rdp, s);
+               return rdp_recv_tpkt_pdu(rdp, s);
        else
-               return rdp_read_fastpath_pdu(rdp, s);
+               return rdp_recv_fastpath_pdu(rdp, s);
 }
 
 /**
@@ -488,7 +484,7 @@ void rdp_recv(rdpRdp* rdp)
        s = transport_recv_stream_init(rdp->transport, 4096);
        transport_read(rdp->transport, s);
 
-       rdp_read_pdu(rdp, s);
+       rdp_recv_pdu(rdp, s);
 }
 
 static int rdp_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
@@ -523,7 +519,7 @@ static int rdp_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
                        break;
 
                case CONNECTION_STATE_ACTIVE:
-                       if (!rdp_read_pdu(rdp, s))
+                       if (!rdp_recv_pdu(rdp, s))
                                return -1;
                        break;
 

diff --git a/libfreerdp-core/redirection.c b/libfreerdp-core/redirection.c
index cd4a36b..a80c55b 100644 (file)
--- a/libfreerdp-core/redirection.c
+++ b/libfreerdp-core/redirection.c
@@ -27,13 +27,17 @@
  * @param sec_flags security flags
  */
 
-void rdp_read_redirection_packet(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_redirection_packet(rdpRdp* rdp, STREAM* s)
 {
        printf("Redirection Packet\n");
+
+       return True;
 }
 
-void rdp_read_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s)
+boolean rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s)
 {
        printf("Enhanced Security Redirection Packet\n");
+
+       return True;
 }
 

diff --git a/libfreerdp-core/redirection.h b/libfreerdp-core/redirection.h
index 78fb9aa..02c6ddf 100644 (file)
--- a/libfreerdp-core/redirection.h
+++ b/libfreerdp-core/redirection.h
@@ -25,7 +25,7 @@
 #include <freerdp/freerdp.h>
 #include <freerdp/utils/stream.h>
 
-void rdp_read_redirection_packet(rdpRdp* rdp, STREAM* s);
-void rdp_read_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_redirection_packet(rdpRdp* rdp, STREAM* s);
+boolean rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s);
 
 #endif /* __REDIRECTION_H */