mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libfreerdp-core: modify parsing functions to return int instead of BOOL to propagate session redirection return code

Browse Source
This commit is contained in:
Marc-André Moreau 2013-11-04 15:52:29 -05:00
parent 1f31fd9ae1
commit 3d339b04d9
9 changed files with 94 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
libfreerdp/core/connection.c
View File

@ -598,15 +598,19 @@ BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s)
return TRUE;
}
BOOL rdp_client_connect_license(rdpRdp* rdp, wStream* s)
int rdp_client_connect_license(rdpRdp* rdp, wStream* s)
{
if (!license_recv(rdp->license, s))
return FALSE;
int status;
status = license_recv(rdp->license, s);
if (status < 0)
return status;
if (rdp->license->state == LICENSE_STATE_ABORTED)
{
fprintf(stderr, "license connection sequence aborted.\n");
return FALSE;
return -1;
}
if (rdp->license->state == LICENSE_STATE_COMPLETED)
@ -614,10 +618,10 @@ BOOL rdp_client_connect_license(rdpRdp* rdp, wStream* s)
rdp_client_transition_to_state(rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE);
}
return TRUE;
return 0;
}
BOOL rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s)
int rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s)
{
BYTE* mark;
UINT16 width;
@ -631,24 +635,23 @@ BOOL rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s)
if (!rdp_recv_demand_active(rdp, s))
{
UINT16 channelId;
Stream_SetPointer(s, mark);
rdp_recv_get_active_header(rdp, s, &channelId);
/* Was Stream_Seek(s, RDP_PACKET_HEADER_MAX_LENGTH);
* but the headers aren't always that length,
* so that could result in a bad offset.
*/
if (!rdp_recv_out_of_sequence_pdu(rdp, s))
return FALSE;
return TRUE;
return rdp_recv_out_of_sequence_pdu(rdp, s);
}
if (rdp->disconnect)
return TRUE;
return 0;
if (!rdp_send_confirm_active(rdp))
return FALSE;
return -1;
input_register_client_callbacks(rdp->input);
@ -666,7 +669,7 @@ BOOL rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s)
return rdp_client_connect_finalize(rdp);
}
BOOL rdp_client_connect_finalize(rdpRdp* rdp)
int rdp_client_connect_finalize(rdpRdp* rdp)
{
/**
* [MS-RDPBCGR] 1.3.1.1 - 8.
@ -675,13 +678,13 @@ BOOL rdp_client_connect_finalize(rdpRdp* rdp)
*/
if (!rdp_send_client_synchronize_pdu(rdp))
return FALSE;
return -1;
if (!rdp_send_client_control_pdu(rdp, CTRLACTION_COOPERATE))
return FALSE;
return -1;
if (!rdp_send_client_control_pdu(rdp, CTRLACTION_REQUEST_CONTROL))
return FALSE;
return -1;
/**
* [MS-RDPBCGR] 2.2.1.17
* Client persistent key list must be sent if a bitmap is
@ -692,13 +695,13 @@ BOOL rdp_client_connect_finalize(rdpRdp* rdp)
if (!rdp->deactivation_reactivation && rdp->settings->BitmapCachePersistEnabled)
{
if (!rdp_send_client_persistent_key_list_pdu(rdp))
return FALSE;
return -1;
}
if (!rdp_send_client_font_list_pdu(rdp, FONTLIST_FIRST | FONTLIST_LAST))
return FALSE;
return -1;
return TRUE;
return 0;
}
int rdp_client_transition_to_state(rdpRdp* rdp, int state)

6
libfreerdp/core/connection.h
View File

@ -52,9 +52,9 @@ BOOL rdp_client_redirect(rdpRdp* rdp);
BOOL rdp_client_connect_mcs_connect_response(rdpRdp* rdp, wStream* s);
BOOL rdp_client_connect_mcs_attach_user_confirm(rdpRdp* rdp, wStream* s);
BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s);
BOOL rdp_client_connect_license(rdpRdp* rdp, wStream* s);
BOOL rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s);
BOOL rdp_client_connect_finalize(rdpRdp* rdp);
int rdp_client_connect_license(rdpRdp* rdp, wStream* s);
int rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s);
int rdp_client_connect_finalize(rdpRdp* rdp);
int rdp_client_transition_to_state(rdpRdp* rdp, int state);
BOOL rdp_server_accept_nego(rdpRdp* rdp, wStream* s);

28
libfreerdp/core/license.c
View File

@ -229,7 +229,7 @@ BOOL license_send(rdpLicense* license, wStream* s, BYTE type)
* @return if the operation completed successfully
*/
BOOL license_recv(rdpLicense* license, wStream* s)
int license_recv(rdpLicense* license, wStream* s)
{
BYTE flags;
BYTE bMsgType;
@ -241,37 +241,41 @@ BOOL license_recv(rdpLicense* license, wStream* s)
if (!rdp_read_header(license->rdp, s, &length, &channelId))
{
fprintf(stderr, "Incorrect RDP header.\n");
return FALSE;
return -1;
}
if (!rdp_read_security_header(s, &securityFlags))
return FALSE;
return -1;
if (securityFlags & SEC_ENCRYPT)
{
if (!rdp_decrypt(license->rdp, s, length - 4, securityFlags))
{
fprintf(stderr, "rdp_decrypt failed\n");
return FALSE;
return -1;
}
}
if (!(securityFlags & SEC_LICENSE_PKT))
{
int status;
if (!(securityFlags & SEC_ENCRYPT))
Stream_Rewind(s, RDP_SECURITY_HEADER_LENGTH);
if (rdp_recv_out_of_sequence_pdu(license->rdp, s) != TRUE)
status = rdp_recv_out_of_sequence_pdu(license->rdp, s);
if (status < 0)
{
fprintf(stderr, "Unexpected license packet.\n");
return FALSE;
return status;
}
return TRUE;
return 0;
}
if (!license_read_preamble(s, &bMsgType, &flags, &wMsgSize)) /* preamble (4 bytes) */
return FALSE;
return -1;
DEBUG_LICENSE("Receiving %s Packet", LICENSE_MESSAGE_STRINGS[bMsgType & 0x1F]);
@ -279,13 +283,13 @@ BOOL license_recv(rdpLicense* license, wStream* s)
{
case LICENSE_REQUEST:
if (!license_read_license_request_packet(license, s))
return FALSE;
return -1;
license_send_new_license_request_packet(license);
break;
case PLATFORM_CHALLENGE:
if (!license_read_platform_challenge_packet(license, s))
return FALSE;
return -1;
license_send_platform_challenge_response_packet(license);
break;
@ -299,7 +303,7 @@ BOOL license_recv(rdpLicense* license, wStream* s)
case ERROR_ALERT:
if (!license_read_error_alert_packet(license, s))
return FALSE;
return -1;
break;
default:
@ -307,7 +311,7 @@ BOOL license_recv(rdpLicense* license, wStream* s)
return FALSE;
}
return TRUE;
return 0;
}
void license_generate_randoms(rdpLicense* license)

2
libfreerdp/core/license.h
View File

@ -200,7 +200,7 @@ struct rdp_license
SCOPE_LIST* ScopeList;
};
BOOL license_recv(rdpLicense* license, wStream* s);
int license_recv(rdpLicense* license, wStream* s);
BOOL license_send(rdpLicense* license, wStream* s, BYTE type);
wStream* license_send_stream_init(rdpLicense* license);

21
libfreerdp/core/rdp.c
View File

@ -672,18 +672,18 @@ int rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
return 0;
}
BOOL rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s)
int rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s)
{
UINT16 type;
UINT16 length;
UINT16 channelId;
if (!rdp_read_share_control_header(s, &length, &type, &channelId))
return FALSE;
return -1;
if (type == PDU_TYPE_DATA)
{
return (rdp_recv_data_pdu(rdp, s) < 0) ? FALSE : TRUE;
return rdp_recv_data_pdu(rdp, s);
}
else if (type == PDU_TYPE_SERVER_REDIRECTION)
{
@ -691,7 +691,7 @@ BOOL rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s)
}
else
{
return FALSE;
return -1;
}
}
@ -815,8 +815,8 @@ static int rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
* - no share control header, nor the 2 byte pad
*/
Stream_Rewind(s, 2);
rdp_recv_enhanced_security_redirection_packet(rdp, s);
return 1; /* 1 = redirection */
return rdp_recv_enhanced_security_redirection_packet(rdp, s);
}
}
@ -854,8 +854,7 @@ static int rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
break;
case PDU_TYPE_SERVER_REDIRECTION:
if (!rdp_recv_enhanced_security_redirection_packet(rdp, s))
return -1;
return rdp_recv_enhanced_security_redirection_packet(rdp, s);
break;
default:
@ -928,13 +927,11 @@ static int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
break;
case CONNECTION_STATE_LICENSING:
if (!rdp_client_connect_license(rdp, s))
status = -1;
status = rdp_client_connect_license(rdp, s);
break;
case CONNECTION_STATE_CAPABILITIES_EXCHANGE:
if (!rdp_client_connect_demand_active(rdp, s))
status = -1;
status = rdp_client_connect_demand_active(rdp, s);
break;
case CONNECTION_STATE_FINALIZATION:

2
libfreerdp/core/rdp.h
View File

@ -191,7 +191,7 @@ BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id);
int rdp_send_channel_data(rdpRdp* rdp, int channel_id, BYTE* data, int size);
BOOL rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s);
int rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s);
void rdp_set_blocking_mode(rdpRdp* rdp, BOOL blocking);
int rdp_check_fds(rdpRdp* rdp);

55
libfreerdp/core/redirection.c
View File

@ -175,7 +175,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
rdpRedirection* redirection = rdp->redirection;
if (Stream_GetRemainingLength(s) < 12)
return FALSE;
return -1;
Stream_Read_UINT16(s, flags); /* flags (2 bytes) */
Stream_Read_UINT16(s, length); /* length (2 bytes) */
@ -192,18 +192,18 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
if (redirection->flags & LB_TARGET_NET_ADDRESS)
{
if (!rdp_redirection_read_string(s, &(redirection->TargetNetAddress)))
return FALSE;
return -1;
}
if (redirection->flags & LB_LOAD_BALANCE_INFO)
{
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
return -1;
Stream_Read_UINT32(s, redirection->LoadBalanceInfoLength);
if (Stream_GetRemainingLength(s) < redirection->LoadBalanceInfoLength)
return FALSE;
return -1;
redirection->LoadBalanceInfo = (BYTE*) malloc(redirection->LoadBalanceInfoLength);
Stream_Read(s, redirection->LoadBalanceInfo, redirection->LoadBalanceInfoLength);
@ -216,7 +216,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
if (redirection->flags & LB_USERNAME)
{
if (!rdp_redirection_read_string(s, &(redirection->Username)))
return FALSE;
return -1;
WLog_Print(redirection->log, WLOG_DEBUG, "Username: %s", redirection->Username);
}
@ -233,7 +233,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
{
/* Note: length (hopefully) includes double zero termination */
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
return -1;
Stream_Read_UINT32(s, redirection->PasswordLength);
redirection->Password = (BYTE*) malloc(redirection->PasswordLength);
@ -248,7 +248,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
if (redirection->flags & LB_TARGET_FQDN)
{
if (!rdp_redirection_read_string(s, &(redirection->TargetFQDN)))
return FALSE;
return -1;
WLog_Print(redirection->log, WLOG_DEBUG, "TargetFQDN: %s", redirection->TargetFQDN);
}
@ -256,7 +256,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
if (redirection->flags & LB_TARGET_NETBIOS_NAME)
{
if (!rdp_redirection_read_string(s, &(redirection->TargetNetBiosName)))
return FALSE;
return -1;
WLog_Print(redirection->log, WLOG_DEBUG, "TargetNetBiosName: %s", redirection->TargetNetBiosName);
}
@ -264,12 +264,12 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
if (redirection->flags & LB_CLIENT_TSV_URL)
{
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
return -1;
Stream_Read_UINT32(s, redirection->TsvUrlLength);
if (Stream_GetRemainingLength(s) < redirection->TsvUrlLength)
return FALSE;
return -1;
redirection->TsvUrl = (BYTE*) malloc(redirection->TsvUrlLength);
Stream_Read(s, redirection->TsvUrl, redirection->TsvUrlLength);
@ -287,7 +287,7 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
UINT32 targetNetAddressesLength;
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
return -1;
Stream_Read_UINT32(s, targetNetAddressesLength);
@ -309,24 +309,37 @@ BOOL rdp_recv_server_redirection_pdu(rdpRdp* rdp, wStream* s)
}
if (!Stream_SafeSeek(s, 8)) /* pad (8 bytes) */
return FALSE;
return -1;
if (redirection->flags & LB_NOREDIRECT)
return TRUE;
else
return rdp_client_redirect(rdp);
return 0;
return rdp_client_redirect(rdp);
}
BOOL rdp_recv_redirection_packet(rdpRdp* rdp, wStream* s)
int rdp_recv_redirection_packet(rdpRdp* rdp, wStream* s)
{
return rdp_recv_server_redirection_pdu(rdp, s);
int status = 0;
status = rdp_recv_server_redirection_pdu(rdp, s);
return status;
}
BOOL rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, wStream* s)
int rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, wStream* s)
{
return Stream_SafeSeek(s, 2) && /* pad2Octets (2 bytes) */
rdp_recv_server_redirection_pdu(rdp, s) &&
Stream_SafeSeek(s, 1); /* pad2Octets (1 byte) */
int status = 0;
if (!Stream_SafeSeek(s, 2)) /* pad2Octets (2 bytes) */
return -1;
status = rdp_recv_server_redirection_pdu(rdp, s);
if (status < 0)
return status;
if (!Stream_SafeSeek(s, 1)) /* pad2Octets (1 byte) */
return -1;
return status;
}
rdpRedirection* redirection_new()

3
libfreerdp/core/redirection.h
View File

@ -50,8 +50,7 @@ struct rdp_redirection
char** TargetNetAddresses;
};
BOOL rdp_recv_redirection_packet(rdpRdp* rdp, wStream* s);
BOOL rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, wStream* s);
int rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, wStream* s);
int rdp_redirection_apply_settings(rdpRdp* rdp);

7
libfreerdp/core/transport.c
View File

@ -969,6 +969,8 @@ static void* transport_client_thread(void* arg)
context = instance->context;
assert(NULL != instance->context);
WLog_Print(transport->log, WLOG_DEBUG, "Starting transport thread");
nCount = 0;
handles[nCount++] = transport->stopEvent;
handles[nCount++] = transport->connectedEvent;
@ -977,10 +979,13 @@ static void* transport_client_thread(void* arg)
if (status == WAIT_OBJECT_0)
{
WLog_Print(transport->log, WLOG_DEBUG, "Terminating transport thread");
ExitThread(0);
return NULL;
}
WLog_Print(transport->log, WLOG_DEBUG, "Asynchronous transport activated");
while (1)
{
nCount = 0;
@ -997,6 +1002,8 @@ static void* transport_client_thread(void* arg)
break;
}
WLog_Print(transport->log, WLOG_DEBUG, "Terminating transport thread");
ExitThread(0);
return NULL;
}