From 9880650557a975ca3c03df8ff9b5e4e55aeef0e4 Mon Sep 17 00:00:00 2001
From: Vic Lee <llyzs@163.com>
Date: Tue, 23 Aug 2011 12:58:10 +0800
Subject: [PATCH] Rename functions.

---
 libfreerdp-core/activation.c  | 20 ++++++++--------
 libfreerdp-core/activation.h  | 14 +++++------
 libfreerdp-core/connection.c  |  2 +-
 libfreerdp-core/fastpath.c    | 21 ++++++++++++++++-
 libfreerdp-core/fastpath.h    |  4 +++-
 libfreerdp-core/info.c        |  4 ++--
 libfreerdp-core/info.h        |  4 ++--
 libfreerdp-core/peer.c        | 19 +++++++--------
 libfreerdp-core/rdp.c         | 44 ++++++++++++++++-------------------
 libfreerdp-core/redirection.c |  8 +++++--
 libfreerdp-core/redirection.h |  4 ++--
 11 files changed, 82 insertions(+), 62 deletions(-)

diff --git a/libfreerdp-core/activation.c b/libfreerdp-core/activation.c
index 510f74845..a3b4520d8 100644
--- 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 a9035a108..be26d4c55 100644
--- 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 a86418012..3a5dab6ca 100644
--- 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 c06bab440..12b1cecd3 100644
--- 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 c1df080d6..bf181ffb9 100644
--- 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 c97ad0659..61a525d1d 100644
--- 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 689f1c19c..199fb0640 100644
--- 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 2cc3c872d..922a97366 100644
--- 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 4710cc61b..865e28e6a 100644
--- 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 cd4a36b08..a80c55b7f 100644
--- 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 78fb9aafd..02c6ddf8c 100644
--- 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 */