mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed tpkt header length checks. 

TPKT header length and consumption of data was not consistently
checked. This adds checks after each packet processed and fixes
any inconsistencies found.
This commit is contained in:
Armin Novak 2020-02-21 09:17:00 +01:00 committed by akallabeth
parent 039bb88fef
commit be714d2a13
10 changed files with 169 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libfreerdp/core/activation.c
View File

@ -196,6 +196,8 @@ BOOL rdp_recv_client_font_list_pdu(wStream* s)
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
/* 2.2.1.18.1 Font List PDU Data (TS_FONT_LIST_PDU) */
Stream_Seek(s, 8);
return TRUE;
}

22
libfreerdp/core/capabilities.c
View File

@ -3836,10 +3836,11 @@ static BOOL rdp_read_capability_sets(wStream* s, rdpSettings* settings, UINT16 n
Stream_SetPosition(s, end);
}
#endif
if (len < totalLength)
if (len > totalLength)
{
if (!Stream_SafeSeek(s, totalLength - len))
return FALSE;
WLog_ERR(TAG, "Capability length expected %" PRIu16 ", actual %" PRIdz, totalLength, len);
return FALSE;
}
return TRUE;
}
@ -3950,6 +3951,9 @@ BOOL rdp_recv_demand_active(rdpRdp* rdp, wStream* s)
return FALSE;
}
if (!Stream_SafeSeek(s, 4)) /* SessionId */
return FALSE;
rdp->update->secondary->glyph_v2 = (rdp->settings->GlyphSupportLevel > GLYPH_SUPPORT_FULL);
return tpkt_ensure_stream_consumed(s, length);
}
@ -4043,9 +4047,8 @@ BOOL rdp_send_demand_active(rdpRdp* rdp)
return status;
}
BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s)
BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength)
{
BOOL status;
rdpSettings* settings;
UINT16 lengthSourceDescriptor;
UINT16 lengthCombinedCapabilities;
@ -4066,8 +4069,8 @@ BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s)
Stream_Seek(s, lengthSourceDescriptor); /* sourceDescriptor */
Stream_Read_UINT16(s, numberCapabilities); /* numberCapabilities (2 bytes) */
Stream_Seek(s, 2); /* pad2Octets (2 bytes) */
status =
rdp_read_capability_sets(s, rdp->settings, numberCapabilities, lengthCombinedCapabilities);
if (!rdp_read_capability_sets(s, rdp->settings, numberCapabilities, lengthCombinedCapabilities))
return FALSE;
if (!settings->ReceivedCapabilities[CAPSET_TYPE_SURFACE_COMMANDS])
{
@ -4108,10 +4111,10 @@ BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s)
settings->LargePointerFlag = 0;
}
return status;
return tpkt_ensure_stream_consumed(s, pduLength);
}
BOOL rdp_write_confirm_active(wStream* s, rdpSettings* settings)
static BOOL rdp_write_confirm_active(wStream* s, rdpSettings* settings)
{
size_t bm, em, lm;
UINT16 numberCapabilities;
@ -4257,6 +4260,7 @@ BOOL rdp_write_confirm_active(wStream* s, rdpSettings* settings)
Stream_Seek_UINT16(s);
#endif
Stream_SetPosition(s, em);
return TRUE;
}

3
libfreerdp/core/capabilities.h
View File

@ -169,8 +169,7 @@ FREERDP_LOCAL BOOL rdp_recv_get_active_header(rdpRdp* rdp, wStream* s, UINT16* p
UINT16* length);
FREERDP_LOCAL BOOL rdp_recv_demand_active(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_send_demand_active(rdpRdp* rdp);
FREERDP_LOCAL BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_write_confirm_active(wStream* s, rdpSettings* settings);
FREERDP_LOCAL BOOL rdp_recv_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength);
FREERDP_LOCAL BOOL rdp_send_confirm_active(rdpRdp* rdp);
#endif /* FREERDP_LIB_CORE_CAPABILITIES_H */

17
libfreerdp/core/channels.c
View File

@ -145,7 +145,7 @@ BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 chann
{
UINT32 length;
UINT32 flags;
int chunkLength;
size_t chunkLength;
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
@ -156,6 +156,7 @@ BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 chann
if (client->VirtualChannelRead)
{
int rc;
UINT32 index;
BOOL found = FALSE;
HANDLE hChannel = 0;
@ -178,16 +179,18 @@ BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 chann
if (!found)
return FALSE;
client->VirtualChannelRead(client, hChannel, Stream_Pointer(s),
Stream_GetRemainingLength(s));
rc = client->VirtualChannelRead(client, hChannel, Stream_Pointer(s), chunkLength);
if (rc < 0)
return FALSE;
}
else if (client->ReceiveChannelData)
{
client->ReceiveChannelData(client, channelId, Stream_Pointer(s), chunkLength, flags,
length);
int rc = client->ReceiveChannelData(client, channelId, Stream_Pointer(s), chunkLength,
flags, length);
if (rc < 0)
return FALSE;
}
return TRUE;
return Stream_SafeSeek(s, chunkLength);
}
static const WtsApiFunctionTable FreeRDP_WtsApiFunctionTable = {

58
libfreerdp/core/connection.c
View File

@ -1380,14 +1380,14 @@ BOOL rdp_server_accept_mcs_channel_join_request(rdpRdp* rdp, wStream* s)
return TRUE;
}
BOOL rdp_server_accept_confirm_active(rdpRdp* rdp, wStream* s)
BOOL rdp_server_accept_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength)
{
freerdp_peer* peer = rdp->context->peer;
if (rdp->state != CONNECTION_STATE_CAPABILITIES_EXCHANGE)
return FALSE;
if (!rdp_recv_confirm_active(rdp, s))
if (!rdp_recv_confirm_active(rdp, s, pduLength))
return FALSE;
if (peer->ClientCapabilities && !peer->ClientCapabilities(peer))
@ -1535,3 +1535,57 @@ int rdp_server_transition_to_state(rdpRdp* rdp, int state)
return status;
}
const char* rdp_client_connection_state_string(int state)
{
switch (state)
{
case CLIENT_STATE_INITIAL:
return "CLIENT_STATE_INITIAL";
case CLIENT_STATE_PRECONNECT_PASSED:
return "CLIENT_STATE_PRECONNECT_PASSED";
case CLIENT_STATE_POSTCONNECT_PASSED:
return "CLIENT_STATE_POSTCONNECT_PASSED";
default:
return "UNKNOWN";
}
}
const char* rdp_server_connection_state_string(int state)
{
switch (state)
{
case CONNECTION_STATE_INITIAL:
return "CONNECTION_STATE_INITIAL";
case CONNECTION_STATE_NEGO:
return "CONNECTION_STATE_NEGO";
case CONNECTION_STATE_NLA:
return "CONNECTION_STATE_NLA";
case CONNECTION_STATE_MCS_CONNECT:
return "CONNECTION_STATE_MCS_CONNECT";
case CONNECTION_STATE_MCS_ERECT_DOMAIN:
return "CONNECTION_STATE_MCS_ERECT_DOMAIN";
case CONNECTION_STATE_MCS_ATTACH_USER:
return "CONNECTION_STATE_MCS_ATTACH_USER";
case CONNECTION_STATE_MCS_CHANNEL_JOIN:
return "CONNECTION_STATE_MCS_CHANNEL_JOIN";
case CONNECTION_STATE_RDP_SECURITY_COMMENCEMENT:
return "CONNECTION_STATE_RDP_SECURITY_COMMENCEMENT";
case CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE:
return "CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE";
case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT:
return "CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT";
case CONNECTION_STATE_LICENSING:
return "CONNECTION_STATE_LICENSING";
case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING:
return "CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING";
case CONNECTION_STATE_CAPABILITIES_EXCHANGE:
return "CONNECTION_STATE_CAPABILITIES_EXCHANGE";
case CONNECTION_STATE_FINALIZATION:
return "CONNECTION_STATE_FINALIZATION";
case CONNECTION_STATE_ACTIVE:
return "CONNECTION_STATE_ACTIVE";
default:
return "UNKNOWN";
}
}

4
libfreerdp/core/connection.h
View File

@ -66,15 +66,17 @@ FREERDP_LOCAL BOOL rdp_client_connect_auto_detect(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL int rdp_client_connect_license(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL int rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL int rdp_client_transition_to_state(rdpRdp* rdp, int state);
FREERDP_LOCAL const char* rdp_client_connection_state_string(int state);
FREERDP_LOCAL BOOL rdp_server_accept_nego(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_mcs_connect_initial(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_mcs_erect_domain_request(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_mcs_attach_user_request(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_mcs_channel_join_request(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_confirm_active(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_accept_confirm_active(rdpRdp* rdp, wStream* s, UINT16 pduLength);
FREERDP_LOCAL BOOL rdp_server_establish_keys(rdpRdp* rdp, wStream* s);
FREERDP_LOCAL BOOL rdp_server_reactivate(rdpRdp* rdp);
FREERDP_LOCAL int rdp_server_transition_to_state(rdpRdp* rdp, int state);
FREERDP_LOCAL const char* rdp_server_connection_state_string(int state);
#endif /* FREERDP_LIB_CORE_CONNECTION_H */

97
libfreerdp/core/peer.c
View File

@ -268,7 +268,7 @@ static BOOL freerdp_peer_check_fds(freerdp_peer* peer)
return TRUE;
}
static BOOL peer_recv_data_pdu(freerdp_peer* client, wStream* s)
static BOOL peer_recv_data_pdu(freerdp_peer* client, wStream* s, UINT16 totalLength)
{
BYTE type;
UINT16 length;
@ -395,13 +395,13 @@ static int peer_recv_tpkt_pdu(freerdp_peer* client, wStream* s)
switch (pduType)
{
case PDU_TYPE_DATA:
if (!peer_recv_data_pdu(client, s))
if (!peer_recv_data_pdu(client, s, pduLength))
return -1;
break;
case PDU_TYPE_CONFIRM_ACTIVE:
if (!rdp_server_accept_confirm_active(rdp, s))
if (!rdp_server_accept_confirm_active(rdp, s, pduLength))
return -1;
break;
@ -416,7 +416,7 @@ static int peer_recv_tpkt_pdu(freerdp_peer* client, wStream* s)
return -1;
}
}
else if (rdp->mcs->messageChannelId && channelId == rdp->mcs->messageChannelId)
else if ((rdp->mcs->messageChannelId > 0) && (channelId == rdp->mcs->messageChannelId))
{
if (!rdp->settings->UseRdpSecurityLayer)
if (!rdp_read_security_header(s, &securityFlags, NULL))
@ -483,9 +483,8 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_INITIAL:
if (!rdp_server_accept_nego(rdp, s))
{
WLog_ERR(
TAG,
"peer_recv_callback: CONNECTION_STATE_INITIAL - rdp_server_accept_nego() fail");
WLog_ERR(TAG, "%s: %s - rdp_server_accept_nego() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -511,8 +510,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_NEGO:
if (!rdp_server_accept_mcs_connect_initial(rdp, s))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_NEGO - "
"rdp_server_accept_mcs_connect_initial() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_server_accept_mcs_connect_initial() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -521,8 +522,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_MCS_CONNECT:
if (!rdp_server_accept_mcs_erect_domain_request(rdp, s))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_MCS_CONNECT - "
"rdp_server_accept_mcs_erect_domain_request() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_server_accept_mcs_erect_domain_request() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -531,8 +534,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_MCS_ERECT_DOMAIN:
if (!rdp_server_accept_mcs_attach_user_request(rdp, s))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_MCS_ERECT_DOMAIN - "
"rdp_server_accept_mcs_attach_user_request() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_server_accept_mcs_attach_user_request() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -541,8 +546,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_MCS_ATTACH_USER:
if (!rdp_server_accept_mcs_channel_join_request(rdp, s))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_MCS_ATTACH_USER - "
"rdp_server_accept_mcs_channel_join_request() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_server_accept_mcs_channel_join_request() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -554,8 +561,9 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (!rdp_server_establish_keys(rdp, s))
{
WLog_ERR(TAG,
"peer_recv_callback: CONNECTION_STATE_RDP_SECURITY_COMMENCEMENT - "
"rdp_server_establish_keys() fail");
"%s: %s - "
"rdp_server_establish_keys() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
}
@ -570,14 +578,15 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE:
if (!rdp_recv_client_info(rdp, s))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE - "
"rdp_recv_client_info() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_recv_client_info() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
rdp_server_transition_to_state(rdp, CONNECTION_STATE_LICENSING);
return peer_recv_callback(transport, NULL, extra);
break;
case CONNECTION_STATE_LICENSING:
{
@ -585,8 +594,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (!client->LicenseCallback)
{
WLog_ERR(TAG, "peer_recv_callback: LicenseCallback has been removed, assuming "
"licensing is ok (please fix your app)");
WLog_ERR(TAG,
"%s: LicenseCallback has been removed, assuming "
"licensing is ok (please fix your app)",
__FUNCTION__);
res = LICENSE_CB_COMPLETED;
}
else
@ -596,8 +607,9 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
{
case LICENSE_CB_INTERNAL_ERROR:
WLog_ERR(TAG,
"peer_recv_callback: CONNECTION_STATE_LICENSING - callback internal "
"error, aborting");
"%s: %s - callback internal "
"error, aborting",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
case LICENSE_CB_ABORT:
@ -611,11 +623,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
return peer_recv_callback(transport, NULL, extra);
default:
WLog_ERR(
TAG,
"peer_recv_callback: CONNECTION_STATE_LICENSING - unknown license callback "
"result %d",
(int)res);
WLog_ERR(TAG,
"%s: CONNECTION_STATE_LICENSING - unknown license callback "
"result %d",
__FUNCTION__, res);
break;
}
@ -630,8 +641,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (!rdp_send_demand_active(rdp))
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_CAPABILITIES_EXCHANGE - "
"rdp_send_demand_active() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_send_demand_active() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -642,8 +655,9 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (peer_recv_pdu(client, s) < 0)
{
WLog_ERR(TAG,
"peer_recv_callback: CONNECTION_STATE_CAPABILITIES_EXCHANGE - "
"peer_recv_pdu() fail");
"%s: %s - "
"peer_recv_pdu() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
}
@ -656,8 +670,10 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
*/
if (peer_recv_pdu(client, s) < 0)
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_CAPABILITIES_EXCHANGE - "
"peer_recv_pdu() fail");
WLog_ERR(TAG,
"%s: %s - "
"peer_recv_pdu() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
return -1;
}
}
@ -667,9 +683,8 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_FINALIZATION:
if (peer_recv_pdu(client, s) < 0)
{
WLog_ERR(
TAG,
"peer_recv_callback: CONNECTION_STATE_FINALIZATION - peer_recv_pdu() fail");
WLog_ERR(TAG, "%s: %s - peer_recv_pdu() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -678,14 +693,16 @@ static int peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_ACTIVE:
if (peer_recv_pdu(client, s) < 0)
{
WLog_ERR(TAG, "peer_recv_callback: CONNECTION_STATE_ACTIVE - peer_recv_pdu() fail");
WLog_ERR(TAG, "%s: %s - peer_recv_pdu() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
break;
default:
WLog_ERR(TAG, "Invalid state %d", rdp->state);
WLog_ERR(TAG, "%s state %d", rdp_server_connection_state_string(rdp->state),
rdp->state);
return -1;
}

33
libfreerdp/core/rdp.c
View File

@ -1433,7 +1433,8 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
{
if (nla_recv_pdu(rdp->nla, s) < 1)
{
WLog_ERR(TAG, "rdp_recv_callback: CONNECTION_STATE_NLA - nla_recv_pdu() fail");
WLog_ERR(TAG, "%s: %s - nla_recv_pdu() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
}
@ -1443,7 +1444,8 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (nego_get_state(rdp->nego) != NEGO_STATE_FINAL)
{
WLog_ERR(TAG, "rdp_recv_callback: CONNECTION_STATE_NLA - nego_recv() fail");
WLog_ERR(TAG, "%s: %s - nego_recv() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
@ -1482,8 +1484,8 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (!mcs_client_begin(rdp->mcs))
{
WLog_ERR(TAG,
"rdp_recv_callback: CONNECTION_STATE_NLA - mcs_client_begin() fail");
WLog_ERR(TAG, "%s: %s - mcs_client_begin() fail", __FUNCTION__,
rdp_server_connection_state_string(rdp->state));
return -1;
}
}
@ -1531,8 +1533,10 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
case CONNECTION_STATE_MCS_CHANNEL_JOIN:
if (!rdp_client_connect_mcs_channel_join_confirm(rdp, s))
{
WLog_ERR(TAG, "rdp_recv_callback: CONNECTION_STATE_MCS_CHANNEL_JOIN - "
"rdp_client_connect_mcs_channel_join_confirm() fail");
WLog_ERR(TAG,
"%s: %s - "
"rdp_client_connect_mcs_channel_join_confirm() fail",
__FUNCTION__, rdp_server_connection_state_string(rdp->state));
status = -1;
}
@ -1542,8 +1546,8 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
status = rdp_client_connect_license(rdp, s);
if (status < 0)
WLog_DBG(TAG, "CONNECTION_STATE_LICENSING - rdp_client_connect_license() - %i",
status);
WLog_DBG(TAG, "%s: %s - rdp_client_connect_license() - %i", __FUNCTION__,
rdp_server_connection_state_string(rdp->state), status);
break;
@ -1552,9 +1556,9 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
if (status < 0)
WLog_DBG(TAG,
"CONNECTION_STATE_CAPABILITIES_EXCHANGE - "
"%s: %s - "
"rdp_client_connect_demand_active() - %i",
status);
__FUNCTION__, rdp_server_connection_state_string(rdp->state), status);
break;
@ -1573,7 +1577,8 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
}
if (status < 0)
WLog_DBG(TAG, "CONNECTION_STATE_FINALIZATION - rdp_recv_pdu() - %i", status);
WLog_DBG(TAG, "%s: %s - rdp_recv_pdu() - %i", __FUNCTION__,
rdp_server_connection_state_string(rdp->state), status);
break;
@ -1581,12 +1586,14 @@ int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
status = rdp_recv_pdu(rdp, s);
if (status < 0)
WLog_DBG(TAG, "CONNECTION_STATE_ACTIVE - rdp_recv_pdu() - %i", status);
WLog_DBG(TAG, "%s: %s - rdp_recv_pdu() - %i", __FUNCTION__,
rdp_server_connection_state_string(rdp->state), status);
break;
default:
WLog_ERR(TAG, "Invalid state %d", rdp->state);
WLog_ERR(TAG, "%s: %s state %d", __FUNCTION__,
rdp_server_connection_state_string(rdp->state), rdp->state);
status = -1;
break;
}

18
libfreerdp/core/server.c
View File

@ -403,27 +403,21 @@ static int WTSReceiveChannelData(freerdp_peer* client, UINT16 channelId, const B
{
UINT32 i;
BOOL status = FALSE;
rdpPeerChannel* channel;
rdpMcs* mcs = client->context->rdp->mcs;
for (i = 0; i < mcs->channelCount; i++)
{
if (mcs->channels[i].ChannelId == channelId)
break;
}
if (i < mcs->channelCount)
{
channel = (rdpPeerChannel*)mcs->channels[i].handle;
if (channel)
{
WTSProcessChannelData(channel, channelId, data, size, flags, totalSize);
status = TRUE;
rdpPeerChannel* channel = (rdpPeerChannel*)mcs->channels[i].handle;
if (channel)
status = WTSProcessChannelData(channel, channelId, data, size, flags, totalSize);
break;
}
}
return status;
return status ? 0 : -1;
}
void WTSVirtualChannelManagerGetFileDescriptor(HANDLE hServer, void** fds, int* fds_count)

2
libfreerdp/core/tpkt.c
View File

@ -27,7 +27,7 @@
#include <winpr/wlog.h>
#define TAG FREERDP_TAG(".core.tpkt")
#define TAG FREERDP_TAG("core.tpkt")
/**
* TPKTs are defined in: