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

libfreerdp-core: MCS cleanup, better handling of domain parameters

This commit is contained in:
Marc-André Moreau 2014-02-13 17:06:33 -05:00
parent b665d892a0
commit e5990fa60c
11 changed files with 331 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libfreerdp/core/activation.c
View File

@ -61,7 +61,7 @@ BOOL rdp_send_server_synchronize_pdu(rdpRdp* rdp)
s = rdp_data_pdu_init(rdp);
rdp_write_synchronize_pdu(s, rdp->settings);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->userId);
}
BOOL rdp_recv_client_synchronize_pdu(rdpRdp* rdp, wStream* s)
@ -92,7 +92,7 @@ BOOL rdp_send_client_synchronize_pdu(rdpRdp* rdp)
rdp_write_synchronize_pdu(s, rdp->settings);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->userId);
}
BOOL rdp_recv_control_pdu(wStream* s, UINT16* action)
@ -146,7 +146,7 @@ BOOL rdp_send_server_control_cooperate_pdu(rdpRdp* rdp)
Stream_Write_UINT16(s, 0); /* grantId (2 bytes) */
Stream_Write_UINT32(s, 0); /* controlId (4 bytes) */
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId);
}
BOOL rdp_send_server_control_granted_pdu(rdpRdp* rdp)
@ -156,10 +156,10 @@ BOOL rdp_send_server_control_granted_pdu(rdpRdp* rdp)
s = rdp_data_pdu_init(rdp);
Stream_Write_UINT16(s, CTRLACTION_GRANTED_CONTROL); /* action (2 bytes) */
Stream_Write_UINT16(s, rdp->mcs->user_id); /* grantId (2 bytes) */
Stream_Write_UINT16(s, rdp->mcs->userId); /* grantId (2 bytes) */
Stream_Write_UINT32(s, 0x03EA); /* controlId (4 bytes) */
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId);
}
BOOL rdp_send_client_control_pdu(rdpRdp* rdp, UINT16 action)
@ -169,7 +169,7 @@ BOOL rdp_send_client_control_pdu(rdpRdp* rdp, UINT16 action)
s = rdp_data_pdu_init(rdp);
rdp_write_client_control_pdu(s, action);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId);
}
void rdp_write_persistent_list_entry(wStream* s, UINT32 key1, UINT32 key2)
@ -204,7 +204,7 @@ BOOL rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp)
s = rdp_data_pdu_init(rdp);
rdp_write_client_persistent_key_list_pdu(s, rdp->settings);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST, rdp->mcs->userId);
}
BOOL rdp_recv_client_font_list_pdu(wStream* s)
@ -230,7 +230,7 @@ BOOL rdp_send_client_font_list_pdu(rdpRdp* rdp, UINT16 flags)
s = rdp_data_pdu_init(rdp);
rdp_write_client_font_list_pdu(s, flags);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_LIST, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_LIST, rdp->mcs->userId);
}
BOOL rdp_recv_font_map_pdu(rdpRdp* rdp, wStream* s)
@ -273,7 +273,7 @@ BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp)
Stream_Write_UINT16(s, FONTLIST_FIRST | FONTLIST_LAST); /* mapFlags (2 bytes) */
Stream_Write_UINT16(s, 4); /* entrySize (2 bytes) */
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->user_id);
return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->userId);
}
BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s)
@ -337,7 +337,7 @@ BOOL rdp_send_deactivate_all(rdpRdp* rdp)
Stream_Write_UINT16(s, 1); /* lengthSourceDescriptor (2 bytes) */
Stream_Write_UINT8(s, 0); /* sourceDescriptor (should be 0x00) */
status = rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->user_id);
status = rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->userId);
Stream_Free(s, TRUE);

8
libfreerdp/core/capabilities.c
View File

@ -3389,7 +3389,7 @@ BOOL rdp_recv_get_active_header(rdpRdp* rdp, wStream* s, UINT16* pChannelId)
if (*pChannelId != MCS_GLOBAL_CHANNEL_ID)
{
UINT16 mcsMessageChannelId = rdp->mcs->message_channel_id;
UINT16 mcsMessageChannelId = rdp->mcs->messageChannelId;
if ((mcsMessageChannelId == 0) || (*pChannelId != mcsMessageChannelId))
{
@ -3526,11 +3526,11 @@ BOOL rdp_send_demand_active(rdpRdp* rdp)
s = Stream_New(NULL, 4096);
rdp_init_stream_pdu(rdp, s);
rdp->settings->ShareId = 0x10000 + rdp->mcs->user_id;
rdp->settings->ShareId = 0x10000 + rdp->mcs->userId;
rdp_write_demand_active(s, rdp->settings);
status = rdp_send_pdu(rdp, s, PDU_TYPE_DEMAND_ACTIVE, rdp->mcs->user_id);
status = rdp_send_pdu(rdp, s, PDU_TYPE_DEMAND_ACTIVE, rdp->mcs->userId);
Stream_Free(s, TRUE);
@ -3741,7 +3741,7 @@ BOOL rdp_send_confirm_active(rdpRdp* rdp)
rdp_write_confirm_active(s, rdp->settings);
status = rdp_send_pdu(rdp, s, PDU_TYPE_CONFIRM_ACTIVE, rdp->mcs->user_id);
status = rdp_send_pdu(rdp, s, PDU_TYPE_CONFIRM_ACTIVE, rdp->mcs->userId);
Stream_Free(s, TRUE);

233
libfreerdp/core/client.c
View File

@ -68,33 +68,6 @@ rdpChannels* freerdp_channels_find_by_open_handle(int OpenHandle, int* pindex)
return (found) ? channels : NULL;
}
rdpChannels* freerdp_channels_find_by_instance(freerdp* instance)
{
int index;
BOOL found = FALSE;
rdpChannels* channels = NULL;
ArrayList_Lock(g_ChannelsList);
index = 0;
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);
while (channels)
{
if (channels->instance == instance)
{
found = TRUE;
break;
}
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);
}
ArrayList_Unlock(g_ChannelsList);
return (found) ? channels : NULL;
}
CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(rdpChannels* channels, const char* channel_name)
{
int index;
@ -162,105 +135,6 @@ rdpChannel* freerdp_channels_find_channel_by_name(rdpChannels* channels,
return NULL;
}
UINT32 FreeRDP_VirtualChannelWrite(UINT32 openHandle, void* pData, UINT32 dataLength, void* pUserData)
{
int index;
rdpChannels* channels;
CHANNEL_OPEN_EVENT* item;
CHANNEL_OPEN_DATA* pChannelOpenData;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
if (!pData)
{
return CHANNEL_RC_NULL_DATA;
}
if (!dataLength)
{
return CHANNEL_RC_ZERO_LENGTH;
}
pChannelOpenData = &channels->openDataList[index];
if (pChannelOpenData->flags != 2)
{
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
item = (CHANNEL_OPEN_EVENT*) malloc(sizeof(CHANNEL_OPEN_EVENT));
item->Data = pData;
item->DataLength = dataLength;
item->UserData = pUserData;
item->Index = index;
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 0, (void*) item, NULL);
return CHANNEL_RC_OK;
}
UINT32 FreeRDP_VirtualChannelEventPush(UINT32 openHandle, wMessage* event)
{
int index;
rdpChannels* channels;
CHANNEL_OPEN_DATA* pChannelOpenData;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
if (!event)
{
return CHANNEL_RC_NULL_DATA;
}
pChannelOpenData = &channels->openDataList[index];
if (pChannelOpenData->flags != 2)
{
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
/**
* We really intend to use the In queue for events, but we're pushing on both
* to wake up threads waiting on the out queue. Doing this cleanly would require
* breaking freerdp_pop_event() a bit too early in this refactoring.
*/
MessageQueue_Post(channels->MsgPipe->In, (void*) channels, 1, (void*) event, NULL);
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 1, (void*) event, NULL);
return CHANNEL_RC_OK;
}
/**
* this is called shortly after the application starts and
* before any other function in the file
@ -428,21 +302,21 @@ int freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
* data coming from the server to the client
* called only from main thread
*/
int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int data_size, int flags, int total_size)
int freerdp_channels_data(freerdp* instance, int channelId, void* data, int dataSize, int flags, int totalSize)
{
int index;
rdpChannel* channel;
rdpChannels* channels;
CHANNEL_OPEN_DATA* pChannelOpenData;
channels = freerdp_channels_find_by_instance(instance);
channels = instance->context->channels;
if (!channels)
{
return 1;
}
channel = freerdp_channels_find_channel_by_id(channels, instance->settings, channel_id, &index);
channel = freerdp_channels_find_channel_by_id(channels, instance->settings, channelId, &index);
if (!channel)
{
@ -459,7 +333,7 @@ int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int dat
if (pChannelOpenData->pChannelOpenEventProc)
{
pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->OpenHandle,
CHANNEL_EVENT_DATA_RECEIVED, data, data_size, total_size, flags);
CHANNEL_EVENT_DATA_RECEIVED, data, dataSize, totalSize, flags);
}
return 0;
@ -867,6 +741,105 @@ UINT32 FreeRDP_VirtualChannelClose(UINT32 openHandle)
return CHANNEL_RC_OK;
}
UINT32 FreeRDP_VirtualChannelWrite(UINT32 openHandle, void* pData, UINT32 dataLength, void* pUserData)
{
int index;
rdpChannels* channels;
CHANNEL_OPEN_EVENT* item;
CHANNEL_OPEN_DATA* pChannelOpenData;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
if (!pData)
{
return CHANNEL_RC_NULL_DATA;
}
if (!dataLength)
{
return CHANNEL_RC_ZERO_LENGTH;
}
pChannelOpenData = &channels->openDataList[index];
if (pChannelOpenData->flags != 2)
{
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
item = (CHANNEL_OPEN_EVENT*) malloc(sizeof(CHANNEL_OPEN_EVENT));
item->Data = pData;
item->DataLength = dataLength;
item->UserData = pUserData;
item->Index = index;
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 0, (void*) item, NULL);
return CHANNEL_RC_OK;
}
UINT32 FreeRDP_VirtualChannelEventPush(UINT32 openHandle, wMessage* event)
{
int index;
rdpChannels* channels;
CHANNEL_OPEN_DATA* pChannelOpenData;
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
if ((!channels) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
{
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
if (!event)
{
return CHANNEL_RC_NULL_DATA;
}
pChannelOpenData = &channels->openDataList[index];
if (pChannelOpenData->flags != 2)
{
return CHANNEL_RC_NOT_OPEN;
}
if (!channels->is_connected)
{
return CHANNEL_RC_NOT_CONNECTED;
}
/**
* We really intend to use the In queue for events, but we're pushing on both
* to wake up threads waiting on the out queue. Doing this cleanly would require
* breaking freerdp_pop_event() a bit too early in this refactoring.
*/
MessageQueue_Post(channels->MsgPipe->In, (void*) channels, 1, (void*) event, NULL);
MessageQueue_Post(channels->MsgPipe->Out, (void*) channels, 1, (void*) event, NULL);
return CHANNEL_RC_OK;
}
int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings, void* entry, void* data)
{
int status;

68
libfreerdp/core/connection.c
View File

@ -547,7 +547,7 @@ BOOL rdp_client_connect_mcs_attach_user_confirm(rdpRdp* rdp, wStream* s)
if (!mcs_recv_attach_user_confirm(rdp->mcs, s))
return FALSE;
if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->user_id))
if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->userId))
return FALSE;
rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CHANNEL_JOIN);
@ -558,35 +558,35 @@ BOOL rdp_client_connect_mcs_attach_user_confirm(rdpRdp* rdp, wStream* s)
BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s)
{
UINT32 i;
UINT16 channel_id;
BOOL all_joined = TRUE;
UINT16 channelId;
BOOL allJoined = TRUE;
if (!mcs_recv_channel_join_confirm(rdp->mcs, s, &channel_id))
if (!mcs_recv_channel_join_confirm(rdp->mcs, s, &channelId))
return FALSE;
if (!rdp->mcs->user_channel_joined)
if (!rdp->mcs->userChannelJoined)
{
if (channel_id != rdp->mcs->user_id)
if (channelId != rdp->mcs->userId)
return FALSE;
rdp->mcs->user_channel_joined = TRUE;
rdp->mcs->userChannelJoined = TRUE;
if (!mcs_send_channel_join_request(rdp->mcs, MCS_GLOBAL_CHANNEL_ID))
return FALSE;
}
else if (!rdp->mcs->global_channel_joined)
else if (!rdp->mcs->globalChannelJoined)
{
if (channel_id != MCS_GLOBAL_CHANNEL_ID)
if (channelId != MCS_GLOBAL_CHANNEL_ID)
return FALSE;
rdp->mcs->global_channel_joined = TRUE;
rdp->mcs->globalChannelJoined = TRUE;
if (rdp->mcs->message_channel_id != 0)
if (rdp->mcs->messageChannelId != 0)
{
if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->message_channel_id))
if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->messageChannelId))
return FALSE;
all_joined = FALSE;
allJoined = FALSE;
}
else
{
@ -595,23 +595,23 @@ BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s)
if (!mcs_send_channel_join_request(rdp->mcs, rdp->settings->ChannelDefArray[0].ChannelId))
return FALSE;
all_joined = FALSE;
allJoined = FALSE;
}
}
}
else if ((rdp->mcs->message_channel_id != 0) && !rdp->mcs->message_channel_joined)
else if ((rdp->mcs->messageChannelId != 0) && !rdp->mcs->messageChannelJoined)
{
if (channel_id != rdp->mcs->message_channel_id)
if (channelId != rdp->mcs->messageChannelId)
return FALSE;
rdp->mcs->message_channel_joined = TRUE;
rdp->mcs->messageChannelJoined = TRUE;
if (rdp->settings->ChannelCount > 0)
{
if (!mcs_send_channel_join_request(rdp->mcs, rdp->settings->ChannelDefArray[0].ChannelId))
return FALSE;
all_joined = FALSE;
allJoined = FALSE;
}
}
else
@ -621,7 +621,7 @@ BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s)
if (rdp->settings->ChannelDefArray[i].joined)
continue;
if (rdp->settings->ChannelDefArray[i].ChannelId != channel_id)
if (rdp->settings->ChannelDefArray[i].ChannelId != channelId)
return FALSE;
rdp->settings->ChannelDefArray[i].joined = TRUE;
@ -633,11 +633,11 @@ BOOL rdp_client_connect_mcs_channel_join_confirm(rdpRdp* rdp, wStream* s)
if (!mcs_send_channel_join_request(rdp->mcs, rdp->settings->ChannelDefArray[i + 1].ChannelId))
return FALSE;
all_joined = FALSE;
allJoined = FALSE;
}
}
if (rdp->mcs->user_channel_joined && rdp->mcs->global_channel_joined && all_joined)
if (rdp->mcs->userChannelJoined && rdp->mcs->globalChannelJoined && allJoined)
{
if (!rdp_client_establish_keys(rdp))
return FALSE;
@ -658,14 +658,14 @@ BOOL rdp_client_connect_auto_detect(rdpRdp* rdp, wStream *s)
UINT16 channelId;
/* If the MCS message channel has been joined... */
if (rdp->mcs->message_channel_id != 0)
if (rdp->mcs->messageChannelId != 0)
{
/* Process any MCS message channel PDUs. */
Stream_GetPointer(s, mark);
if (rdp_read_header(rdp, s, &length, &channelId))
{
if (channelId == rdp->mcs->message_channel_id)
if (channelId == rdp->mcs->messageChannelId)
{
if (rdp_recv_message_channel_pdu(rdp, s) == 0)
return TRUE;
@ -970,30 +970,30 @@ BOOL rdp_server_accept_mcs_attach_user_request(rdpRdp* rdp, wStream* s)
BOOL rdp_server_accept_mcs_channel_join_request(rdpRdp* rdp, wStream* s)
{
UINT32 i;
UINT16 channel_id;
BOOL all_joined = TRUE;
UINT16 channelId;
BOOL allJoined = TRUE;
if (!mcs_recv_channel_join_request(rdp->mcs, s, &channel_id))
if (!mcs_recv_channel_join_request(rdp->mcs, s, &channelId))
return FALSE;
if (!mcs_send_channel_join_confirm(rdp->mcs, channel_id))
if (!mcs_send_channel_join_confirm(rdp->mcs, channelId))
return FALSE;
if (channel_id == rdp->mcs->user_id)
rdp->mcs->user_channel_joined = TRUE;
else if (channel_id == MCS_GLOBAL_CHANNEL_ID)
rdp->mcs->global_channel_joined = TRUE;
if (channelId == rdp->mcs->userId)
rdp->mcs->userChannelJoined = TRUE;
else if (channelId == MCS_GLOBAL_CHANNEL_ID)
rdp->mcs->globalChannelJoined = TRUE;
for (i = 0; i < rdp->settings->ChannelCount; i++)
{
if (rdp->settings->ChannelDefArray[i].ChannelId == channel_id)
if (rdp->settings->ChannelDefArray[i].ChannelId == channelId)
rdp->settings->ChannelDefArray[i].joined = TRUE;
if (!rdp->settings->ChannelDefArray[i].joined)
all_joined = FALSE;
allJoined = FALSE;
}
if ((rdp->mcs->user_channel_joined) && (rdp->mcs->global_channel_joined) && all_joined)
if ((rdp->mcs->userChannelJoined) && (rdp->mcs->globalChannelJoined) && allJoined)
{
rdp_server_transition_to_state(rdp, CONNECTION_STATE_RDP_SECURITY_COMMENCEMENT);
}

4
libfreerdp/core/freerdp.c
View File

@ -298,9 +298,9 @@ int freerdp_message_queue_process_pending_messages(freerdp* instance, DWORD id)
return status;
}
static int freerdp_send_channel_data(freerdp* instance, int channel_id, BYTE* data, int size)
static int freerdp_send_channel_data(freerdp* instance, int channelId, BYTE* data, int size)
{
return rdp_send_channel_data(instance->context->rdp, channel_id, data, size);
return rdp_send_channel_data(instance->context->rdp, channelId, data, size);
}
BOOL freerdp_disconnect(freerdp* instance)

8
libfreerdp/core/gcc.c
View File

@ -281,14 +281,14 @@ BOOL gcc_read_conference_create_response(wStream* s, rdpSettings* settings)
return TRUE;
}
void gcc_write_conference_create_response(wStream* s, wStream* user_data)
void gcc_write_conference_create_response(wStream* s, wStream* userData)
{
/* ConnectData */
per_write_choice(s, 0);
per_write_object_identifier(s, t124_02_98_oid);
/* ConnectData::connectPDU (OCTET_STRING) */
per_write_length(s, Stream_GetPosition(user_data) + 2);
per_write_length(s, Stream_GetPosition(userData) + 2);
/* ConnectGCCPDU */
per_write_choice(s, 0x14);
@ -312,7 +312,7 @@ void gcc_write_conference_create_response(wStream* s, wStream* user_data)
per_write_octet_string(s, h221_sc_key, 4, 4); /* h221NonStandard, server-to-client H.221 key, "McDn" */
/* userData (OCTET_STRING) */
per_write_octet_string(s, user_data->buffer, Stream_GetPosition(user_data), 0); /* array of server data blocks */
per_write_octet_string(s, userData->buffer, Stream_GetPosition(userData), 0); /* array of server data blocks */
}
BOOL gcc_read_client_data_blocks(wStream* s, rdpSettings* settings, int length)
@ -1504,7 +1504,7 @@ BOOL gcc_read_server_message_channel_data(wStream* s, rdpSettings* settings)
/* Save the MCS message channel id */
instance = (freerdp*) settings->instance;
instance->context->rdp->mcs->message_channel_id = MCSChannelId;
instance->context->rdp->mcs->messageChannelId = MCSChannelId;
return TRUE;
}

2
libfreerdp/core/input.c
View File

@ -52,7 +52,7 @@ wStream* rdp_client_input_pdu_init(rdpRdp* rdp, UINT16 type)
void rdp_send_client_input_pdu(rdpRdp* rdp, wStream* s)
{
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_INPUT, rdp->mcs->user_id);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_INPUT, rdp->mcs->userId);
}
void input_write_synchronize_event(wStream* s, UINT32 flags)

179
libfreerdp/core/mcs.c
View File

@ -320,6 +320,121 @@ void mcs_print_domain_parameters(DomainParameters* domainParameters)
fprintf(stderr, "}\n");
}
/**
* Merge MCS Domain Parameters.
* @param domainParameters target parameters
* @param domainParameters minimum parameters
* @param domainParameters maximum parameters
* @param domainParameters output parameters
*/
BOOL mcs_merge_domain_parameters(DomainParameters* targetParameters, DomainParameters* minimumParameters,
DomainParameters* maximumParameters, DomainParameters* pOutParameters)
{
/* maxChannelIds */
if (targetParameters->maxChannelIds >= 4)
{
pOutParameters->maxChannelIds = targetParameters->maxChannelIds;
}
else if (maximumParameters->maxChannelIds >= 4)
{
pOutParameters->maxChannelIds = 4;
}
else
{
return FALSE;
}
/* maxUserIds */
if (targetParameters->maxUserIds >= 3)
{
pOutParameters->maxUserIds = targetParameters->maxUserIds;
}
else if (maximumParameters->maxUserIds >= 3)
{
pOutParameters->maxUserIds = 3;
}
else
{
return FALSE;
}
/* maxTokenIds */
pOutParameters->maxTokenIds = targetParameters->maxTokenIds;
/* numPriorities */
if (minimumParameters->numPriorities <= 1)
{
pOutParameters->numPriorities = 1;
}
else
{
return FALSE;
}
/* minThroughput */
pOutParameters->minThroughput = targetParameters->minThroughput;
/* maxHeight */
if ((targetParameters->maxHeight == 1) || (minimumParameters->maxHeight <= 1))
{
pOutParameters->maxHeight = 1;
}
else
{
return FALSE;
}
/* maxMCSPDUsize */
if (targetParameters->maxMCSPDUsize >= 1024)
{
if (targetParameters->maxMCSPDUsize <= 65528)
{
pOutParameters->maxMCSPDUsize = targetParameters->maxMCSPDUsize;
}
else if ((minimumParameters->maxMCSPDUsize >= 124) && (minimumParameters->maxMCSPDUsize <= 65528))
{
pOutParameters->maxMCSPDUsize = 65528;
}
else
{
return FALSE;
}
}
else
{
if (maximumParameters->maxMCSPDUsize >= 124)
{
pOutParameters->maxMCSPDUsize = maximumParameters->maxMCSPDUsize;
}
else
{
return FALSE;
}
}
/* protocolVersion */
if ((targetParameters->protocolVersion == 2) ||
((minimumParameters->protocolVersion <= 2) && (maximumParameters->protocolVersion >= 2)))
{
pOutParameters->protocolVersion = 2;
}
else
{
return FALSE;
}
return TRUE;
}
/**
* Read an MCS Connect Initial PDU.\n
* @msdn{cc240508}
@ -329,7 +444,7 @@ void mcs_print_domain_parameters(DomainParameters* domainParameters)
BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s)
{
UINT16 li;
UINT16 li;
int length;
BOOL upwardFlag;
@ -373,6 +488,10 @@ BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s)
if (!gcc_read_conference_create_request(s, mcs->transport->settings))
return FALSE;
if (!mcs_merge_domain_parameters(&mcs->targetParameters, &mcs->minimumParameters,
&mcs->maximumParameters, &mcs->domainParameters))
return FALSE;
return TRUE;
}
@ -384,7 +503,7 @@ BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s)
* @param user_data GCC Conference Create Request
*/
void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* user_data)
void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData)
{
int length;
wStream* tmps;
@ -410,7 +529,7 @@ void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* user_data)
mcs_write_domain_parameters(tmps, &mcs->maximumParameters);
/* userData (OCTET_STRING) */
ber_write_octet_string(tmps, user_data->buffer, Stream_GetPosition(user_data));
ber_write_octet_string(tmps, userData->buffer, Stream_GetPosition(userData));
length = Stream_GetPosition(tmps);
/* Connect-Initial (APPLICATION 101, IMPLICIT SEQUENCE) */
@ -427,7 +546,7 @@ void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* user_data)
* @param user_data GCC Conference Create Response
*/
void mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* user_data)
void mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData)
{
int length;
wStream* tmps;
@ -435,10 +554,9 @@ void mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* user_data)
tmps = Stream_New(NULL, Stream_Capacity(s));
ber_write_enumerated(tmps, 0, MCS_Result_enum_length);
ber_write_integer(tmps, 0); /* calledConnectId */
mcs->domainParameters = mcs->targetParameters;
mcs_write_domain_parameters(tmps, &(mcs->domainParameters));
/* userData (OCTET_STRING) */
ber_write_octet_string(tmps, user_data->buffer, Stream_GetPosition(user_data));
ber_write_octet_string(tmps, userData->buffer, Stream_GetPosition(userData));
length = Stream_GetPosition(tmps);
ber_write_application_tag(s, MCS_TYPE_CONNECT_RESPONSE, length);
@ -680,16 +798,18 @@ BOOL mcs_send_attach_user_request(rdpMcs* mcs)
BOOL mcs_recv_attach_user_confirm(rdpMcs* mcs, wStream* s)
{
UINT16 length;
BOOL status;
BYTE result;
UINT16 length;
enum DomainMCSPDU MCSPDU;
MCSPDU = DomainMCSPDU_AttachUserConfirm;
return
mcs_read_domain_mcspdu_header(s, &MCSPDU, &length) &&
status = mcs_read_domain_mcspdu_header(s, &MCSPDU, &length) &&
per_read_enumerated(s, &result, MCS_Result_enum_length) && /* result */
per_read_integer16(s, &(mcs->user_id), MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_read_integer16(s, &(mcs->userId), MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
return status;
}
/**
@ -703,14 +823,17 @@ BOOL mcs_send_attach_user_confirm(rdpMcs* mcs)
wStream* s;
int status;
UINT16 length = 11;
rdpSettings* settings;
s = Stream_New(NULL, length);
settings = mcs->transport->settings;
mcs->userId = MCS_GLOBAL_CHANNEL_ID + 1 + settings->ChannelCount;
mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserConfirm, length, 2);
per_write_enumerated(s, 0, MCS_Result_enum_length); /* result */
mcs->user_id = MCS_GLOBAL_CHANNEL_ID + 1 + mcs->transport->settings->ChannelCount;
per_write_integer16(s, mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
Stream_SealLength(s);
@ -728,19 +851,19 @@ BOOL mcs_send_attach_user_confirm(rdpMcs* mcs)
* @param s stream
*/
BOOL mcs_recv_channel_join_request(rdpMcs* mcs, wStream* s, UINT16* channel_id)
BOOL mcs_recv_channel_join_request(rdpMcs* mcs, wStream* s, UINT16* channelId)
{
UINT16 length;
UINT16 userId;
enum DomainMCSPDU MCSPDU;
UINT16 user_id;
MCSPDU = DomainMCSPDU_ChannelJoinRequest;
return
mcs_read_domain_mcspdu_header(s, &MCSPDU, &length) &&
per_read_integer16(s, &user_id, MCS_BASE_CHANNEL_ID) &&
(user_id == mcs->user_id) &&
per_read_integer16(s, channel_id, 0);
per_read_integer16(s, &userId, MCS_BASE_CHANNEL_ID) &&
(userId == mcs->userId) &&
per_read_integer16(s, channelId, 0);
}
/**
@ -750,7 +873,7 @@ BOOL mcs_recv_channel_join_request(rdpMcs* mcs, wStream* s, UINT16* channel_id)
* @param channel_id channel id
*/
BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channel_id)
BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channelId)
{
wStream* s;
int status;
@ -760,8 +883,8 @@ BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channel_id)
mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinRequest, length, 0);
per_write_integer16(s, mcs->user_id, MCS_BASE_CHANNEL_ID);
per_write_integer16(s, channel_id, 0);
per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID);
per_write_integer16(s, channelId, 0);
Stream_SealLength(s);
@ -778,7 +901,7 @@ BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channel_id)
* @param mcs mcs module
*/
BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channel_id)
BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channelId)
{
BOOL status;
UINT16 length;
@ -794,7 +917,7 @@ BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channel_id)
status &= per_read_enumerated(s, &result, MCS_Result_enum_length); /* result */
status &= per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
status &= per_read_integer16(s, &requested, 0); /* requested (ChannelId) */
status &= per_read_integer16(s, channel_id, 0); /* channelId */
status &= per_read_integer16(s, channelId, 0); /* channelId */
return status;
}
@ -805,7 +928,7 @@ BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channel_id)
* @param mcs mcs module
*/
BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channel_id)
BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channelId)
{
wStream* s;
int status;
@ -816,9 +939,9 @@ BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channel_id)
mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinConfirm, length, 2);
per_write_enumerated(s, 0, MCS_Result_enum_length); /* result */
per_write_integer16(s, mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_write_integer16(s, channel_id, 0); /* requested (ChannelId) */
per_write_integer16(s, channel_id, 0); /* channelId */
per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_write_integer16(s, channelId, 0); /* requested (ChannelId) */
per_write_integer16(s, channelId, 0); /* channelId */
Stream_SealLength(s);
@ -913,7 +1036,7 @@ rdpMcs* mcs_new(rdpTransport* transport)
mcs = (rdpMcs*) malloc(sizeof(rdpMcs));
if (mcs != NULL)
if (mcs)
{
ZeroMemory(mcs, sizeof(rdpMcs));
@ -933,7 +1056,7 @@ rdpMcs* mcs_new(rdpTransport* transport)
void mcs_free(rdpMcs* mcs)
{
if (mcs != NULL)
if (mcs)
{
free(mcs);
}

25
libfreerdp/core/mcs.h
View File

@ -127,17 +127,17 @@ struct rdp_mcs
{
rdpTransport* transport;
UINT16 user_id;
UINT16 message_channel_id;
UINT16 userId;
UINT16 messageChannelId;
DomainParameters domainParameters;
DomainParameters targetParameters;
DomainParameters minimumParameters;
DomainParameters maximumParameters;
BOOL user_channel_joined;
BOOL global_channel_joined;
BOOL message_channel_joined;
BOOL userChannelJoined;
BOOL globalChannelJoined;
BOOL messageChannelJoined;
};
#define MCS_SEND_DATA_HEADER_MAX_LENGTH 8
@ -145,8 +145,11 @@ struct rdp_mcs
#define MCS_TYPE_CONNECT_INITIAL 0x65
#define MCS_TYPE_CONNECT_RESPONSE 0x66
void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* user_data);
void mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* user_data);
BOOL mcs_merge_domain_parameters(DomainParameters* targetParameters, DomainParameters* minimumParameters,
DomainParameters* maximumParameters, DomainParameters* pOutParameters);
void mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData);
void mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData);
BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s);
BOOL mcs_send_connect_initial(rdpMcs* mcs);
@ -158,10 +161,10 @@ BOOL mcs_recv_attach_user_request(rdpMcs* mcs, wStream* s);
BOOL mcs_send_attach_user_request(rdpMcs* mcs);
BOOL mcs_recv_attach_user_confirm(rdpMcs* mcs, wStream* s);
BOOL mcs_send_attach_user_confirm(rdpMcs* mcs);
BOOL mcs_recv_channel_join_request(rdpMcs* mcs, wStream* s, UINT16* channel_id);
BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channel_id);
BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channel_id);
BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channel_id);
BOOL mcs_recv_channel_join_request(rdpMcs* mcs, wStream* s, UINT16* channelId);
BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channelId);
BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channelId);
BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channelId);
BOOL mcs_recv_disconnect_provider_ultimatum(rdpMcs* mcs, wStream* s, int* reason);
BOOL mcs_send_disconnect_provider_ultimatum(rdpMcs* mcs);
BOOL mcs_read_domain_mcspdu_header(wStream* s, enum DomainMCSPDU* domainMCSPDU, UINT16* length);

10
libfreerdp/core/rdp.c
View File

@ -361,7 +361,7 @@ void rdp_write_header(rdpRdp* rdp, wStream* s, UINT16 length, UINT16 channelId)
}
mcs_write_domain_mcspdu_header(s, MCSPDU, length, 0);
per_write_integer16(s, rdp->mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator */
per_write_integer16(s, rdp->mcs->userId, MCS_BASE_CHANNEL_ID); /* initiator */
per_write_integer16(s, channelId, 0); /* channelId */
Stream_Write_UINT8(s, 0x70); /* dataPriority + segmentation */
/*
@ -555,7 +555,7 @@ BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags)
length = Stream_GetPosition(s);
Stream_SetPosition(s, 0);
rdp_write_header(rdp, s, length, rdp->mcs->message_channel_id);
rdp_write_header(rdp, s, length, rdp->mcs->messageChannelId);
sec_bytes = rdp_get_sec_bytes(rdp);
sec_hold = Stream_GetPosition(s);
@ -1050,7 +1050,7 @@ static int rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
Stream_SetPosition(s, nextPosition);
}
}
else if (channelId == rdp->mcs->message_channel_id)
else if (channelId == rdp->mcs->messageChannelId)
{
return rdp_recv_message_channel_pdu(rdp, s);
}
@ -1161,9 +1161,9 @@ static int rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
return status;
}
int rdp_send_channel_data(rdpRdp* rdp, int channel_id, BYTE* data, int size)
int rdp_send_channel_data(rdpRdp* rdp, int channelId, BYTE* data, int size)
{
return freerdp_channel_send(rdp, channel_id, data, size);
return freerdp_channel_send(rdp, channelId, data, size);
}
/**

6
libfreerdp/core/update.c
View File

@ -749,7 +749,7 @@ static void update_send_refresh_rect(rdpContext* context, BYTE count, RECTANGLE_
s = rdp_data_pdu_init(rdp);
update_write_refresh_rect(s, count, areas);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_REFRESH_RECT, rdp->mcs->user_id);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_REFRESH_RECT, rdp->mcs->userId);
Stream_Release(s);
}
}
@ -778,7 +778,7 @@ static void update_send_suppress_output(rdpContext* context, BYTE allow, RECTANG
s = rdp_data_pdu_init(rdp);
update_write_suppress_output(s, allow, area);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SUPPRESS_OUTPUT, rdp->mcs->user_id);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SUPPRESS_OUTPUT, rdp->mcs->userId);
Stream_Release(s);
}
}
@ -838,7 +838,7 @@ static void update_send_frame_acknowledge(rdpContext* context, UINT32 frameId)
{
s = rdp_data_pdu_init(rdp);
Stream_Write_UINT32(s, frameId);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FRAME_ACKNOWLEDGE, rdp->mcs->user_id);
rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FRAME_ACKNOWLEDGE, rdp->mcs->userId);
Stream_Release(s);
}
}