2011-07-05 01:05:58 +04:00
|
|
|
/**
|
2012-10-09 07:02:04 +04:00
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
2011-07-05 01:05:58 +04:00
|
|
|
* T.124 Generic Conference Control (GCC)
|
|
|
|
*
|
|
|
|
* Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2012-08-15 01:09:01 +04:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2012-09-24 02:41:07 +04:00
|
|
|
#include <freerdp/utils/unicode.h>
|
2011-08-31 12:35:50 +04:00
|
|
|
|
2011-07-05 01:05:58 +04:00
|
|
|
#include "gcc.h"
|
2011-09-05 22:02:52 +04:00
|
|
|
#include "certificate.h"
|
2011-07-05 01:05:58 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* T.124 GCC is defined in:
|
|
|
|
*
|
|
|
|
* http://www.itu.int/rec/T-REC-T.124-199802-S/en
|
|
|
|
* ITU-T T.124 (02/98): Generic Conference Control
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ConnectData ::= SEQUENCE
|
|
|
|
* {
|
|
|
|
* t124Identifier Key,
|
|
|
|
* connectPDU OCTET_STRING
|
|
|
|
* }
|
|
|
|
*
|
2011-07-05 03:13:01 +04:00
|
|
|
* Key ::= CHOICE
|
|
|
|
* {
|
|
|
|
* object OBJECT_IDENTIFIER,
|
|
|
|
* h221NonStandard H221NonStandardIdentifier
|
|
|
|
* }
|
|
|
|
*
|
2011-07-05 01:05:58 +04:00
|
|
|
* ConnectGCCPDU ::= CHOICE
|
|
|
|
* {
|
|
|
|
* conferenceCreateRequest ConferenceCreateRequest,
|
|
|
|
* conferenceCreateResponse ConferenceCreateResponse,
|
|
|
|
* conferenceQueryRequest ConferenceQueryRequest,
|
|
|
|
* conferenceQueryResponse ConferenceQueryResponse,
|
|
|
|
* conferenceJoinRequest ConferenceJoinRequest,
|
|
|
|
* conferenceJoinResponse ConferenceJoinResponse,
|
|
|
|
* conferenceInviteRequest ConferenceInviteRequest,
|
|
|
|
* conferenceInviteResponse ConferenceInviteResponse,
|
|
|
|
* ...
|
|
|
|
* }
|
2011-07-05 03:13:01 +04:00
|
|
|
*
|
|
|
|
* ConferenceCreateRequest ::= SEQUENCE
|
|
|
|
* {
|
|
|
|
* conferenceName ConferenceName,
|
|
|
|
* convenerPassword Password OPTIONAL,
|
|
|
|
* password Password OPTIONAL,
|
|
|
|
* lockedConference BOOLEAN,
|
|
|
|
* listedConference BOOLEAN,
|
|
|
|
* conductibleConference BOOLEAN,
|
|
|
|
* terminationMethod TerminationMethod,
|
|
|
|
* conductorPrivileges SET OF Privilege OPTIONAL,
|
|
|
|
* conductedPrivileges SET OF Privilege OPTIONAL,
|
|
|
|
* nonConductedPrivileges SET OF Privilege OPTIONAL,
|
|
|
|
* conferenceDescription TextString OPTIONAL,
|
|
|
|
* callerIdentifier TextString OPTIONAL,
|
|
|
|
* userData UserData OPTIONAL,
|
|
|
|
* ...,
|
|
|
|
* conferencePriority ConferencePriority OPTIONAL,
|
|
|
|
* conferenceMode ConferenceMode OPTIONAL
|
|
|
|
* }
|
|
|
|
*
|
2011-07-10 01:28:30 +04:00
|
|
|
* ConferenceCreateResponse ::= SEQUENCE
|
|
|
|
* {
|
|
|
|
* nodeID UserID,
|
|
|
|
* tag INTEGER,
|
|
|
|
* result ENUMERATED
|
|
|
|
* {
|
|
|
|
* success (0),
|
|
|
|
* userRejected (1),
|
|
|
|
* resourcesNotAvailable (2),
|
|
|
|
* rejectedForSymmetryBreaking (3),
|
|
|
|
* lockedConferenceNotSupported (4)
|
|
|
|
* },
|
|
|
|
* userData UserData OPTIONAL,
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
*
|
2011-07-05 03:13:01 +04:00
|
|
|
* ConferenceName ::= SEQUENCE
|
|
|
|
* {
|
|
|
|
* numeric SimpleNumericString
|
|
|
|
* text SimpleTextString OPTIONAL,
|
|
|
|
* ...
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* SimpleNumericString ::= NumericString (SIZE (1..255)) (FROM ("0123456789"))
|
|
|
|
*
|
|
|
|
* UserData ::= SET OF SEQUENCE
|
|
|
|
* {
|
|
|
|
* key Key,
|
|
|
|
* value OCTET_STRING OPTIONAL
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* H221NonStandardIdentifier ::= OCTET STRING (SIZE (4..255))
|
|
|
|
*
|
2011-07-10 01:28:30 +04:00
|
|
|
* UserID ::= DynamicChannelID
|
|
|
|
*
|
|
|
|
* ChannelID ::= INTEGER (1..65535)
|
|
|
|
* StaticChannelID ::= INTEGER (1..1000)
|
|
|
|
* DynamicChannelID ::= INTEGER (1001..65535)
|
|
|
|
*
|
2011-07-05 01:05:58 +04:00
|
|
|
*/
|
|
|
|
|
2011-07-05 03:13:01 +04:00
|
|
|
/*
|
|
|
|
* OID = 0.0.20.124.0.1
|
|
|
|
* { itu-t(0) recommendation(0) t(20) t124(124) version(0) 1 }
|
|
|
|
* v.1 of ITU-T Recommendation T.124 (Feb 1998): "Generic Conference Control"
|
|
|
|
*/
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE t124_02_98_oid[6] = { 0, 0, 20, 124, 0, 1 };
|
2011-07-05 03:13:01 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE h221_cs_key[4] = "Duca";
|
|
|
|
BYTE h221_sc_key[4] = "McDn";
|
2011-07-10 01:28:30 +04:00
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a GCC Conference Create Request.\n
|
|
|
|
* @msdn{cc240836}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_conference_create_request(STREAM* s, rdpSettings* settings)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 length;
|
|
|
|
BYTE choice;
|
|
|
|
BYTE number;
|
|
|
|
BYTE selection;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* ConnectData */
|
|
|
|
if (!per_read_choice(s, &choice))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (!per_read_object_identifier(s, t124_02_98_oid))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* ConnectData::connectPDU (OCTET_STRING) */
|
|
|
|
if (!per_read_length(s, &length))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* ConnectGCCPDU */
|
|
|
|
if (!per_read_choice(s, &choice))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (!per_read_selection(s, &selection))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* ConferenceCreateRequest::conferenceName */
|
|
|
|
if (!per_read_numeric_string(s, 1)) /* ConferenceName::numeric */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (!per_read_padding(s, 1)) /* padding */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* UserData (SET OF SEQUENCE) */
|
|
|
|
if (!per_read_number_of_sets(s, &number) || number != 1) /* one set of UserData */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (!per_read_choice(s, &choice) || choice != 0xC0) /* UserData::value present + select h221NonStandard (1) */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* h221NonStandard */
|
|
|
|
if (!per_read_octet_string(s, h221_cs_key, 4, 4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* userData::value (OCTET_STRING) */
|
|
|
|
if (!per_read_length(s, &length))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (stream_get_left(s) < length)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
if (!gcc_read_client_data_blocks(s, settings, length))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 05:35:32 +04:00
|
|
|
/**
|
|
|
|
* Write a GCC Conference Create Request.\n
|
|
|
|
* @msdn{cc240836}
|
|
|
|
* @param s stream
|
|
|
|
* @param user_data client data blocks
|
|
|
|
*/
|
|
|
|
|
2011-07-10 01:28:30 +04:00
|
|
|
void gcc_write_conference_create_request(STREAM* s, STREAM* user_data)
|
2011-07-05 03:13:01 +04:00
|
|
|
{
|
|
|
|
/* ConnectData */
|
|
|
|
per_write_choice(s, 0); /* From Key select object (0) of type OBJECT_IDENTIFIER */
|
|
|
|
per_write_object_identifier(s, t124_02_98_oid); /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */
|
|
|
|
|
|
|
|
/* ConnectData::connectPDU (OCTET_STRING) */
|
|
|
|
per_write_length(s, stream_get_length(user_data) + 14); /* connectPDU length */
|
|
|
|
|
|
|
|
/* ConnectGCCPDU */
|
|
|
|
per_write_choice(s, 0); /* From ConnectGCCPDU select conferenceCreateRequest (0) of type ConferenceCreateRequest */
|
|
|
|
per_write_selection(s, 0x08); /* select optional userData from ConferenceCreateRequest */
|
|
|
|
|
|
|
|
/* ConferenceCreateRequest::conferenceName */
|
2012-10-09 11:01:37 +04:00
|
|
|
per_write_numeric_string(s, (BYTE*)"1", 1, 1); /* ConferenceName::numeric */
|
2011-07-05 03:13:01 +04:00
|
|
|
per_write_padding(s, 1); /* padding */
|
|
|
|
|
|
|
|
/* UserData (SET OF SEQUENCE) */
|
|
|
|
per_write_number_of_sets(s, 1); /* one set of UserData */
|
|
|
|
per_write_choice(s, 0xC0); /* UserData::value present + select h221NonStandard (1) */
|
2011-07-05 01:05:58 +04:00
|
|
|
|
2011-07-05 03:13:01 +04:00
|
|
|
/* h221NonStandard */
|
2011-07-10 01:28:30 +04:00
|
|
|
per_write_octet_string(s, h221_cs_key, 4, 4); /* h221NonStandard, client-to-server H.221 key, "Duca" */
|
2011-07-05 01:05:58 +04:00
|
|
|
|
2011-07-05 03:13:01 +04:00
|
|
|
/* userData::value (OCTET_STRING) */
|
2011-07-06 07:18:00 +04:00
|
|
|
per_write_octet_string(s, user_data->data, stream_get_length(user_data), 0); /* array of client data blocks */
|
2011-07-05 03:13:01 +04:00
|
|
|
}
|
2011-07-05 06:02:00 +04:00
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_conference_create_response(STREAM* s, rdpSettings* settings)
|
2011-07-10 01:28:30 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 length;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 tag;
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 nodeID;
|
|
|
|
BYTE result;
|
|
|
|
BYTE choice;
|
|
|
|
BYTE number;
|
2011-07-10 01:28:30 +04:00
|
|
|
|
|
|
|
/* ConnectData */
|
|
|
|
per_read_choice(s, &choice);
|
|
|
|
per_read_object_identifier(s, t124_02_98_oid);
|
|
|
|
|
|
|
|
/* ConnectData::connectPDU (OCTET_STRING) */
|
|
|
|
per_read_length(s, &length);
|
|
|
|
|
|
|
|
/* ConnectGCCPDU */
|
|
|
|
per_read_choice(s, &choice);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::nodeID (UserID) */
|
|
|
|
per_read_integer16(s, &nodeID, 1001);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::tag (INTEGER) */
|
|
|
|
per_read_integer(s, &tag);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::result (ENUMERATED) */
|
2011-07-10 07:54:23 +04:00
|
|
|
per_read_enumerated(s, &result, MCS_Result_enum_length);
|
2011-07-10 01:28:30 +04:00
|
|
|
|
|
|
|
/* number of UserData sets */
|
|
|
|
per_read_number_of_sets(s, &number);
|
|
|
|
|
|
|
|
/* UserData::value present + select h221NonStandard (1) */
|
|
|
|
per_read_choice(s, &choice);
|
|
|
|
|
|
|
|
/* h221NonStandard */
|
2011-09-05 22:02:52 +04:00
|
|
|
if (!per_read_octet_string(s, h221_sc_key, 4, 4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-07-10 01:28:30 +04:00
|
|
|
|
|
|
|
/* userData (OCTET_STRING) */
|
|
|
|
per_read_length(s, &length);
|
2011-08-22 11:03:58 +04:00
|
|
|
if (!gcc_read_server_data_blocks(s, settings, length))
|
2011-09-05 22:02:52 +04:00
|
|
|
{
|
|
|
|
printf("gcc_read_conference_create_response: gcc_read_server_data_blocks failed\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 19:56:47 +04:00
|
|
|
void gcc_write_conference_create_response(STREAM* s, STREAM* user_data)
|
|
|
|
{
|
|
|
|
/* ConnectData */
|
|
|
|
per_write_choice(s, 0);
|
|
|
|
per_write_object_identifier(s, t124_02_98_oid);
|
|
|
|
|
|
|
|
/* ConnectData::connectPDU (OCTET_STRING) */
|
|
|
|
per_write_length(s, stream_get_length(user_data) + 2);
|
|
|
|
|
|
|
|
/* ConnectGCCPDU */
|
|
|
|
per_write_choice(s, 0x14);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::nodeID (UserID) */
|
|
|
|
per_write_integer16(s, 0x79F3, 1001);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::tag (INTEGER) */
|
|
|
|
per_write_integer(s, 1);
|
|
|
|
|
|
|
|
/* ConferenceCreateResponse::result (ENUMERATED) */
|
|
|
|
per_write_enumerated(s, 0, MCS_Result_enum_length);
|
|
|
|
|
|
|
|
/* number of UserData sets */
|
|
|
|
per_write_number_of_sets(s, 1);
|
|
|
|
|
|
|
|
/* UserData::value present + select h221NonStandard (1) */
|
|
|
|
per_write_choice(s, 0xC0);
|
|
|
|
|
|
|
|
/* h221NonStandard */
|
|
|
|
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->data, stream_get_length(user_data), 0); /* array of server data blocks */
|
|
|
|
}
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_client_data_blocks(STREAM* s, rdpSettings* settings, int length)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 type;
|
|
|
|
UINT16 blockLength;
|
2011-08-19 13:39:37 +04:00
|
|
|
int pos;
|
|
|
|
|
|
|
|
while (length > 0)
|
|
|
|
{
|
|
|
|
pos = stream_get_pos(s);
|
|
|
|
gcc_read_user_data_header(s, &type, &blockLength);
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case CS_CORE:
|
|
|
|
if (!gcc_read_client_core_data(s, settings, blockLength - 4))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CS_SECURITY:
|
2011-08-19 14:11:33 +04:00
|
|
|
if (!gcc_read_client_security_data(s, settings, blockLength - 4))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CS_NET:
|
2011-08-19 14:11:33 +04:00
|
|
|
if (!gcc_read_client_network_data(s, settings, blockLength - 4))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CS_CLUSTER:
|
2011-08-19 14:11:33 +04:00
|
|
|
if (!gcc_read_client_cluster_data(s, settings, blockLength - 4))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CS_MONITOR:
|
2011-08-19 14:11:33 +04:00
|
|
|
if (!gcc_read_client_monitor_data(s, settings, blockLength - 4))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
length -= blockLength;
|
|
|
|
stream_set_pos(s, pos + blockLength);
|
|
|
|
}
|
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 21:10:56 +04:00
|
|
|
void gcc_write_client_data_blocks(STREAM* s, rdpSettings* settings)
|
2011-07-10 07:54:23 +04:00
|
|
|
{
|
|
|
|
gcc_write_client_core_data(s, settings);
|
|
|
|
gcc_write_client_cluster_data(s, settings);
|
|
|
|
gcc_write_client_security_data(s, settings);
|
|
|
|
gcc_write_client_network_data(s, settings);
|
2011-12-18 21:10:56 +04:00
|
|
|
|
|
|
|
/* extended client data supported */
|
|
|
|
|
2012-12-13 23:38:02 +04:00
|
|
|
if (settings->NegotiationFlags & EXTENDED_CLIENT_DATA_SUPPORTED)
|
|
|
|
{
|
|
|
|
if (!settings->SpanMonitors)
|
|
|
|
{
|
|
|
|
gcc_write_client_monitor_data(s, settings);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (settings->UseMultimon)
|
|
|
|
{
|
|
|
|
printf("WARNING: true multi monitor support was not advertised by server!\n");
|
|
|
|
|
|
|
|
if (settings->ForceMultimon)
|
|
|
|
{
|
|
|
|
printf("Sending multi monitor information anyway (may break connectivity!)\n");
|
|
|
|
gcc_write_client_monitor_data(s, settings);
|
|
|
|
}
|
2012-12-14 01:29:16 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("Use /multimon:force to force sending multi monitor information\n");
|
|
|
|
}
|
2012-12-13 23:38:02 +04:00
|
|
|
}
|
|
|
|
}
|
2011-07-10 07:54:23 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_server_data_blocks(STREAM* s, rdpSettings* settings, int length)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 type;
|
|
|
|
UINT16 offset = 0;
|
|
|
|
UINT16 blockLength;
|
|
|
|
BYTE* holdp;
|
2011-07-10 05:04:57 +04:00
|
|
|
|
|
|
|
while (offset < length)
|
|
|
|
{
|
2011-09-05 22:02:52 +04:00
|
|
|
holdp = s->p;
|
|
|
|
|
2011-08-22 11:03:58 +04:00
|
|
|
if (!gcc_read_user_data_header(s, &type, &blockLength))
|
2011-09-05 22:02:52 +04:00
|
|
|
{
|
|
|
|
printf("gcc_read_server_data_blocks: gcc_read_user_data_header failed\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
2011-07-10 05:04:57 +04:00
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case SC_CORE:
|
2011-08-22 11:03:58 +04:00
|
|
|
if (!gcc_read_server_core_data(s, settings))
|
2011-09-05 22:02:52 +04:00
|
|
|
{
|
|
|
|
printf("gcc_read_server_data_blocks: gcc_read_server_core_data failed\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
2011-07-10 05:04:57 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SC_SECURITY:
|
2011-08-22 11:03:58 +04:00
|
|
|
if (!gcc_read_server_security_data(s, settings))
|
2011-09-05 22:02:52 +04:00
|
|
|
{
|
|
|
|
printf("gcc_read_server_data_blocks: gcc_read_server_security_data failed\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
2011-07-10 05:04:57 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SC_NET:
|
2011-08-22 11:03:58 +04:00
|
|
|
if (!gcc_read_server_network_data(s, settings))
|
2011-09-05 22:02:52 +04:00
|
|
|
{
|
|
|
|
printf("gcc_read_server_data_blocks: gcc_read_server_network_data failed\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
2011-07-10 05:04:57 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2012-01-25 20:04:19 +04:00
|
|
|
printf("gcc_read_server_data_blocks: ignoring type=%hu\n", type);
|
2011-07-10 05:04:57 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += blockLength;
|
2011-09-05 22:02:52 +04:00
|
|
|
s->p = holdp + blockLength;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_server_data_blocks(STREAM* s, rdpSettings* settings)
|
2011-08-19 19:56:47 +04:00
|
|
|
{
|
|
|
|
gcc_write_server_core_data(s, settings);
|
|
|
|
gcc_write_server_network_data(s, settings);
|
|
|
|
gcc_write_server_security_data(s, settings);
|
|
|
|
}
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_user_data_header(STREAM* s, UINT16* type, UINT16* length)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, *type); /* type */
|
|
|
|
stream_read_UINT16(s, *length); /* length */
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-01-16 00:20:39 +04:00
|
|
|
if (*length < 4)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2012-01-16 00:20:39 +04:00
|
|
|
|
2011-08-22 11:03:58 +04:00
|
|
|
if (stream_get_left(s) < *length - 4)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 01:28:30 +04:00
|
|
|
}
|
|
|
|
|
2011-07-06 02:26:12 +04:00
|
|
|
/**
|
|
|
|
* Write a user data header (TS_UD_HEADER).\n
|
|
|
|
* @msdn{cc240509}
|
|
|
|
* @param s stream
|
|
|
|
* @param type data block type
|
|
|
|
* @param length data block length
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
void gcc_write_user_data_header(STREAM* s, UINT16 type, UINT16 length)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, type); /* type */
|
|
|
|
stream_write_UINT16(s, length); /* length */
|
2011-07-06 02:26:12 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a client core data block (TS_UD_CS_CORE).\n
|
|
|
|
* @msdn{cc240510}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_client_core_data(STREAM* s, rdpSettings* settings, UINT16 blockLength)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2012-02-21 09:56:55 +04:00
|
|
|
char* str;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 version;
|
|
|
|
UINT32 color_depth;
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 colorDepth = 0;
|
|
|
|
UINT16 postBeta2ColorDepth = 0;
|
|
|
|
UINT16 highColorDepth = 0;
|
|
|
|
UINT16 supportedColorDepths = 0;
|
|
|
|
UINT16 earlyCapabilityFlags = 0;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 serverSelectedProtocol = 0;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
/* Length of all required fields, until imeFileName */
|
|
|
|
if (blockLength < 128)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_read_UINT32(s, version); /* version */
|
2012-11-07 19:33:06 +04:00
|
|
|
settings->RdpVersion = (version == RDP_VERSION_4 ? 4 : 7);
|
2011-08-19 13:39:37 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_read_UINT16(s, settings->DesktopWidth); /* DesktopWidth */
|
|
|
|
stream_read_UINT16(s, settings->DesktopHeight); /* DesktopHeight */
|
|
|
|
stream_read_UINT16(s, colorDepth); /* ColorDepth */
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_seek_UINT16(s); /* SASSequence (Secure Access Sequence) */
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_read_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout */
|
|
|
|
stream_read_UINT32(s, settings->ClientBuild); /* ClientBuild */
|
2012-02-11 17:22:13 +04:00
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
|
2012-09-24 04:11:50 +04:00
|
|
|
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &str, 32 / 2);
|
2011-08-19 13:39:37 +04:00
|
|
|
stream_seek(s, 32);
|
2012-11-08 00:13:14 +04:00
|
|
|
snprintf(settings->ClientHostname, 31, "%s", str);
|
|
|
|
settings->ClientHostname[31] = 0;
|
2012-10-09 07:21:26 +04:00
|
|
|
free(str);
|
2011-08-19 13:39:37 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_read_UINT32(s, settings->KeyboardType); /* KeyboardType */
|
|
|
|
stream_read_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType */
|
|
|
|
stream_read_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey */
|
2011-08-19 13:39:37 +04:00
|
|
|
|
|
|
|
stream_seek(s, 64); /* imeFileName */
|
|
|
|
|
|
|
|
blockLength -= 128;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The following fields are all optional. If one field is present, all of the preceding
|
|
|
|
* fields MUST also be present. If one field is not present, all of the subsequent fields
|
|
|
|
* MUST NOT be present.
|
|
|
|
* We must check the bytes left before reading each field.
|
|
|
|
*/
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (blockLength < 2)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, postBeta2ColorDepth); /* postBeta2ColorDepth */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 2;
|
|
|
|
|
|
|
|
if (blockLength < 2)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_seek_UINT16(s); /* clientProductID */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 2;
|
|
|
|
|
|
|
|
if (blockLength < 4)
|
|
|
|
break;
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_seek_UINT32(s); /* serialNumber */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 4;
|
|
|
|
|
|
|
|
if (blockLength < 2)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, highColorDepth); /* highColorDepth */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 2;
|
|
|
|
|
|
|
|
if (blockLength < 2)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, supportedColorDepths); /* supportedColorDepths */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 2;
|
|
|
|
|
|
|
|
if (blockLength < 2)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 2;
|
|
|
|
|
|
|
|
if (blockLength < 64)
|
|
|
|
break;
|
2012-09-24 04:11:50 +04:00
|
|
|
|
|
|
|
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &str, 64 / 2);
|
2011-08-19 13:39:37 +04:00
|
|
|
stream_seek(s, 64);
|
2012-11-08 00:13:14 +04:00
|
|
|
snprintf(settings->ClientProductId, 32, "%s", str);
|
2012-10-09 07:21:26 +04:00
|
|
|
free(str);
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 64;
|
|
|
|
|
|
|
|
if (blockLength < 1)
|
|
|
|
break;
|
2012-11-08 00:13:14 +04:00
|
|
|
stream_read_BYTE(s, settings->PerformanceFlags); /* connectionType */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 1;
|
|
|
|
|
|
|
|
if (blockLength < 1)
|
|
|
|
break;
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_seek_BYTE(s); /* pad1octet */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 1;
|
|
|
|
|
|
|
|
if (blockLength < 4)
|
|
|
|
break;
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_read_UINT32(s, serverSelectedProtocol); /* serverSelectedProtocol */
|
2011-08-19 13:39:37 +04:00
|
|
|
blockLength -= 4;
|
|
|
|
|
2012-11-07 20:02:46 +04:00
|
|
|
if (settings->SelectedProtocol != serverSelectedProtocol)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 13:39:37 +04:00
|
|
|
} while (0);
|
|
|
|
|
2011-08-19 14:11:33 +04:00
|
|
|
if (highColorDepth > 0)
|
2012-11-07 19:33:06 +04:00
|
|
|
{
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = highColorDepth;
|
2012-11-07 19:33:06 +04:00
|
|
|
}
|
2011-08-19 14:11:33 +04:00
|
|
|
else if (postBeta2ColorDepth > 0)
|
|
|
|
{
|
|
|
|
switch (postBeta2ColorDepth)
|
|
|
|
{
|
|
|
|
case RNS_UD_COLOR_4BPP:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 4;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
case RNS_UD_COLOR_8BPP:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 8;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
case RNS_UD_COLOR_16BPP_555:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 15;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
case RNS_UD_COLOR_16BPP_565:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 16;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
case RNS_UD_COLOR_24BPP:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 24;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
default:
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (colorDepth)
|
|
|
|
{
|
|
|
|
case RNS_UD_COLOR_4BPP:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 4;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
case RNS_UD_COLOR_8BPP:
|
2012-02-11 17:22:13 +04:00
|
|
|
color_depth = 8;
|
2011-08-19 14:11:33 +04:00
|
|
|
break;
|
|
|
|
default:
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-11 17:22:13 +04:00
|
|
|
/*
|
2012-09-24 03:49:13 +04:00
|
|
|
* If we are in server mode, accept client's color depth only if
|
2012-02-11 17:22:13 +04:00
|
|
|
* it is smaller than ours. This is what Windows server does.
|
|
|
|
*/
|
2012-11-08 03:23:25 +04:00
|
|
|
if (color_depth < settings->ColorDepth || !settings->ServerMode)
|
2012-11-07 19:33:06 +04:00
|
|
|
settings->ColorDepth = color_depth;
|
2012-02-11 17:22:13 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 06:02:00 +04:00
|
|
|
/**
|
|
|
|
* Write a client core data block (TS_UD_CS_CORE).\n
|
|
|
|
* @msdn{cc240510}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_client_core_data(STREAM* s, rdpSettings* settings)
|
2011-07-05 06:02:00 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 version;
|
2012-09-24 03:49:13 +04:00
|
|
|
WCHAR* clientName;
|
|
|
|
int clientNameLength;
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE connectionType;
|
|
|
|
UINT16 highColorDepth;
|
|
|
|
UINT16 supportedColorDepths;
|
|
|
|
UINT16 earlyCapabilityFlags;
|
2012-09-24 03:49:13 +04:00
|
|
|
WCHAR* clientDigProductId;
|
|
|
|
int clientDigProductIdLength;
|
2011-07-06 02:26:12 +04:00
|
|
|
|
|
|
|
gcc_write_user_data_header(s, CS_CORE, 216);
|
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
version = settings->RdpVersion >= 5 ? RDP_VERSION_5_PLUS : RDP_VERSION_4;
|
2012-09-24 03:49:13 +04:00
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
clientNameLength = freerdp_AsciiToUnicodeAlloc(settings->ClientHostname, &clientName, 0);
|
|
|
|
clientDigProductIdLength = freerdp_AsciiToUnicodeAlloc(settings->ClientProductId, &clientDigProductId, 0);
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_write_UINT32(s, version); /* Version */
|
|
|
|
stream_write_UINT16(s, settings->DesktopWidth); /* DesktopWidth */
|
|
|
|
stream_write_UINT16(s, settings->DesktopHeight); /* DesktopHeight */
|
|
|
|
stream_write_UINT16(s, RNS_UD_COLOR_8BPP); /* ColorDepth, ignored because of postBeta2ColorDepth */
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, RNS_UD_SAS_DEL); /* SASSequence (Secure Access Sequence) */
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_write_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout */
|
|
|
|
stream_write_UINT32(s, settings->ClientBuild); /* ClientBuild */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2011-07-08 08:37:25 +04:00
|
|
|
/* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
|
2012-09-24 03:49:13 +04:00
|
|
|
|
|
|
|
if (clientNameLength > 15)
|
2011-07-08 08:37:25 +04:00
|
|
|
{
|
2012-09-24 03:49:13 +04:00
|
|
|
clientNameLength = 15;
|
2011-07-08 08:37:25 +04:00
|
|
|
clientName[clientNameLength] = 0;
|
|
|
|
}
|
2012-09-24 03:49:13 +04:00
|
|
|
|
|
|
|
stream_write(s, clientName, ((clientNameLength + 1) * 2));
|
|
|
|
stream_write_zero(s, 32 - ((clientNameLength + 1) * 2));
|
2012-10-09 07:21:26 +04:00
|
|
|
free(clientName);
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_write_UINT32(s, settings->KeyboardType); /* KeyboardType */
|
|
|
|
stream_write_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType */
|
|
|
|
stream_write_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2011-07-07 19:27:24 +04:00
|
|
|
stream_write_zero(s, 64); /* imeFileName */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, RNS_UD_COLOR_8BPP); /* postBeta2ColorDepth */
|
|
|
|
stream_write_UINT16(s, 1); /* clientProductID */
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, 0); /* serialNumber (should be initialized to 0) */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
highColorDepth = MIN(settings->ColorDepth, 24);
|
2011-07-08 23:32:06 +04:00
|
|
|
|
|
|
|
supportedColorDepths =
|
|
|
|
RNS_UD_24BPP_SUPPORT |
|
|
|
|
RNS_UD_16BPP_SUPPORT |
|
|
|
|
RNS_UD_15BPP_SUPPORT;
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
connectionType = settings->ConnectionType;
|
2011-07-06 02:26:12 +04:00
|
|
|
earlyCapabilityFlags = RNS_UD_CS_SUPPORT_ERRINFO_PDU;
|
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
if (settings->RemoteFxCodec)
|
2011-07-06 02:26:12 +04:00
|
|
|
connectionType = CONNECTION_TYPE_LAN;
|
2011-12-16 21:14:16 +04:00
|
|
|
|
|
|
|
if (connectionType != 0)
|
|
|
|
earlyCapabilityFlags |= RNS_UD_CS_VALID_CONNECTION_TYPE;
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
if (settings->ColorDepth == 32)
|
2011-07-08 08:37:25 +04:00
|
|
|
{
|
|
|
|
supportedColorDepths |= RNS_UD_32BPP_SUPPORT;
|
2011-07-06 02:26:12 +04:00
|
|
|
earlyCapabilityFlags |= RNS_UD_CS_WANT_32BPP_SESSION;
|
2011-07-08 08:37:25 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, highColorDepth); /* highColorDepth */
|
|
|
|
stream_write_UINT16(s, supportedColorDepths); /* supportedColorDepths */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
|
2011-07-08 08:37:25 +04:00
|
|
|
|
|
|
|
/* clientDigProductId (64 bytes, null-terminated unicode, truncated to 30 characters) */
|
|
|
|
if (clientDigProductIdLength > 62)
|
|
|
|
{
|
|
|
|
clientDigProductIdLength = 62;
|
|
|
|
clientDigProductId[clientDigProductIdLength] = 0;
|
|
|
|
clientDigProductId[clientDigProductIdLength + 1] = 0;
|
|
|
|
}
|
|
|
|
stream_write(s, clientDigProductId, clientDigProductIdLength + 2);
|
|
|
|
stream_write_zero(s, 64 - clientDigProductIdLength - 2);
|
2012-10-09 07:21:26 +04:00
|
|
|
free(clientDigProductId);
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_BYTE(s, connectionType); /* connectionType */
|
|
|
|
stream_write_BYTE(s, 0); /* pad1octet */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-07 20:02:46 +04:00
|
|
|
stream_write_UINT32(s, settings->SelectedProtocol); /* serverSelectedProtocol */
|
2011-07-05 06:02:00 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_server_core_data(STREAM* s, rdpSettings* settings)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 version;
|
|
|
|
UINT32 clientRequestedProtocols;
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_read_UINT32(s, version); /* version */
|
|
|
|
stream_read_UINT32(s, clientRequestedProtocols); /* clientRequestedProtocols */
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
if (version == RDP_VERSION_4 && settings->RdpVersion > 4)
|
|
|
|
settings->RdpVersion = 4;
|
|
|
|
else if (version == RDP_VERSION_5_PLUS && settings->RdpVersion < 5)
|
|
|
|
settings->RdpVersion = 7;
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_server_core_data(STREAM* s, rdpSettings* settings)
|
2011-08-19 19:56:47 +04:00
|
|
|
{
|
|
|
|
gcc_write_user_data_header(s, SC_CORE, 12);
|
|
|
|
|
2012-11-07 19:33:06 +04:00
|
|
|
stream_write_UINT32(s, settings->RdpVersion == 4 ? RDP_VERSION_4 : RDP_VERSION_5_PLUS);
|
2012-11-07 20:02:46 +04:00
|
|
|
stream_write_UINT32(s, settings->RequestedProtocols); /* clientRequestedProtocols */
|
2011-08-19 19:56:47 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a client security data block (TS_UD_CS_SEC).\n
|
|
|
|
* @msdn{cc240511}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_client_security_data(STREAM* s, rdpSettings* settings, UINT16 blockLength)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2011-08-19 14:11:33 +04:00
|
|
|
if (blockLength < 8)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->DisableEncryption)
|
2012-01-25 20:04:19 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_read_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
|
|
|
|
if (settings->EncryptionMethods == 0)
|
|
|
|
stream_read_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
|
2012-01-25 20:04:19 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stream_seek(s, 8);
|
|
|
|
}
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 06:02:00 +04:00
|
|
|
/**
|
|
|
|
* Write a client security data block (TS_UD_CS_SEC).\n
|
|
|
|
* @msdn{cc240511}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_client_security_data(STREAM* s, rdpSettings* settings)
|
2011-07-05 06:02:00 +04:00
|
|
|
{
|
2011-07-06 02:26:12 +04:00
|
|
|
gcc_write_user_data_header(s, CS_SECURITY, 12);
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->DisableEncryption)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, 0); /* extEncryptionMethods */
|
2011-07-06 02:26:12 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* French locale, disable encryption */
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, 0); /* encryptionMethods */
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
|
2011-07-06 02:26:12 +04:00
|
|
|
}
|
2011-07-05 06:02:00 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_server_security_data(STREAM* s, rdpSettings* settings)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE* data;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 length;
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_read_UINT32(s, settings->EncryptionMethods); /* encryptionMethod */
|
2012-11-07 20:02:46 +04:00
|
|
|
stream_read_UINT32(s, settings->EncryptionLevel); /* encryptionLevel */
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->EncryptionMethods == 0 && settings->EncryptionLevel == 0)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
|
|
|
/* serverRandom and serverRandom must not be present */
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->DisableEncryption = FALSE;
|
|
|
|
settings->EncryptionMethods = ENCRYPTION_METHOD_NONE;
|
2012-11-07 20:02:46 +04:00
|
|
|
settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE;
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
stream_read_UINT32(s, settings->ServerRandomLength); /* serverRandomLen */
|
|
|
|
stream_read_UINT32(s, settings->ServerCertificateLength); /* serverCertLen */
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
if (settings->ServerRandomLength > 0)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
|
|
|
/* serverRandom */
|
2012-11-08 00:13:14 +04:00
|
|
|
settings->ServerRandom = (BYTE*) malloc(settings->ServerRandomLength);
|
|
|
|
stream_read(s, settings->ServerRandom, settings->ServerRandomLength);
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
2011-09-05 22:02:52 +04:00
|
|
|
else
|
|
|
|
{
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
if (settings->ServerCertificateLength > 0)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
|
|
|
/* serverCertificate */
|
2012-11-08 00:13:14 +04:00
|
|
|
settings->ServerCertificate = (BYTE*) malloc(settings->ServerCertificateLength);
|
|
|
|
stream_read(s, settings->ServerCertificate, settings->ServerCertificateLength);
|
2012-09-24 12:40:32 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
certificate_free(settings->RdpServerCertificate);
|
|
|
|
settings->RdpServerCertificate = certificate_new();
|
2012-11-08 00:13:14 +04:00
|
|
|
data = settings->ServerCertificate;
|
|
|
|
length = settings->ServerCertificateLength;
|
2012-01-14 23:42:36 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (!certificate_read_server_certificate(settings->RdpServerCertificate, data, length))
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-09-05 22:02:52 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
static const BYTE initial_signature[] =
|
2012-01-30 00:05:34 +04:00
|
|
|
{
|
2012-01-25 20:00:40 +04:00
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01
|
2012-02-21 09:56:55 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Terminal Services Signing Keys.
|
|
|
|
* Yes, Terminal Services Private Key is publicly available.
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
const BYTE tssk_modulus[] =
|
2012-02-21 09:56:55 +04:00
|
|
|
{
|
|
|
|
0x3d, 0x3a, 0x5e, 0xbd, 0x72, 0x43, 0x3e, 0xc9,
|
|
|
|
0x4d, 0xbb, 0xc1, 0x1e, 0x4a, 0xba, 0x5f, 0xcb,
|
|
|
|
0x3e, 0x88, 0x20, 0x87, 0xef, 0xf5, 0xc1, 0xe2,
|
|
|
|
0xd7, 0xb7, 0x6b, 0x9a, 0xf2, 0x52, 0x45, 0x95,
|
|
|
|
0xce, 0x63, 0x65, 0x6b, 0x58, 0x3a, 0xfe, 0xef,
|
|
|
|
0x7c, 0xe7, 0xbf, 0xfe, 0x3d, 0xf6, 0x5c, 0x7d,
|
|
|
|
0x6c, 0x5e, 0x06, 0x09, 0x1a, 0xf5, 0x61, 0xbb,
|
|
|
|
0x20, 0x93, 0x09, 0x5f, 0x05, 0x6d, 0xea, 0x87
|
|
|
|
};
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
const BYTE tssk_privateExponent[] =
|
2012-02-21 09:56:55 +04:00
|
|
|
{
|
|
|
|
0x87, 0xa7, 0x19, 0x32, 0xda, 0x11, 0x87, 0x55,
|
|
|
|
0x58, 0x00, 0x16, 0x16, 0x25, 0x65, 0x68, 0xf8,
|
|
|
|
0x24, 0x3e, 0xe6, 0xfa, 0xe9, 0x67, 0x49, 0x94,
|
|
|
|
0xcf, 0x92, 0xcc, 0x33, 0x99, 0xe8, 0x08, 0x60,
|
|
|
|
0x17, 0x9a, 0x12, 0x9f, 0x24, 0xdd, 0xb1, 0x24,
|
|
|
|
0x99, 0xc7, 0x3a, 0xb8, 0x0a, 0x7b, 0x0d, 0xdd,
|
|
|
|
0x35, 0x07, 0x79, 0x17, 0x0b, 0x51, 0x9b, 0xb3,
|
|
|
|
0xc7, 0x10, 0x01, 0x13, 0xe7, 0x3f, 0xf3, 0x5f
|
|
|
|
};
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
const BYTE tssk_exponent[] =
|
2012-02-21 09:56:55 +04:00
|
|
|
{
|
|
|
|
0x5b, 0x7b, 0x88, 0xc0
|
2012-01-25 20:00:40 +04:00
|
|
|
};
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_server_security_data(STREAM* s, rdpSettings* settings)
|
2011-08-19 19:56:47 +04:00
|
|
|
{
|
2012-01-30 00:05:34 +04:00
|
|
|
CryptoMd5 md5;
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE* sigData;
|
2012-01-25 20:00:40 +04:00
|
|
|
int expLen, keyLen, sigDataLen;
|
2012-10-09 11:01:37 +04:00
|
|
|
BYTE encryptedSignature[TSSK_KEY_LENGTH];
|
|
|
|
BYTE signature[sizeof(initial_signature)];
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 headerLen, serverRandomLen, serverCertLen, wPublicKeyBlobLen;
|
2012-01-25 20:00:40 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (!settings->DisableEncryption)
|
2012-01-30 00:05:34 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->EncryptionMethods = ENCRYPTION_METHOD_NONE;
|
2012-11-07 20:02:46 +04:00
|
|
|
settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE;
|
2012-01-25 20:00:40 +04:00
|
|
|
}
|
2012-11-08 08:29:24 +04:00
|
|
|
else if ((settings->EncryptionMethods & ENCRYPTION_METHOD_FIPS) != 0)
|
2012-01-25 20:00:40 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->EncryptionMethods = ENCRYPTION_METHOD_FIPS;
|
2012-01-25 20:00:40 +04:00
|
|
|
}
|
2012-11-08 08:29:24 +04:00
|
|
|
else if ((settings->EncryptionMethods & ENCRYPTION_METHOD_128BIT) != 0)
|
2012-01-25 20:00:40 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->EncryptionMethods = ENCRYPTION_METHOD_128BIT;
|
2012-01-25 20:00:40 +04:00
|
|
|
}
|
2012-11-08 08:29:24 +04:00
|
|
|
else if ((settings->EncryptionMethods & ENCRYPTION_METHOD_40BIT) != 0)
|
2012-01-25 20:00:40 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->EncryptionMethods = ENCRYPTION_METHOD_40BIT;
|
2012-01-25 20:00:40 +04:00
|
|
|
}
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->EncryptionMethods != ENCRYPTION_METHOD_NONE)
|
2012-11-07 20:02:46 +04:00
|
|
|
settings->EncryptionLevel = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE;
|
2012-01-25 20:00:40 +04:00
|
|
|
|
|
|
|
headerLen = 12;
|
|
|
|
keyLen = 0;
|
|
|
|
wPublicKeyBlobLen = 0;
|
|
|
|
serverRandomLen = 0;
|
|
|
|
serverCertLen = 0;
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->EncryptionMethods != ENCRYPTION_METHOD_NONE ||
|
2012-11-07 20:02:46 +04:00
|
|
|
settings->EncryptionLevel != ENCRYPTION_LEVEL_NONE)
|
2012-01-30 00:05:34 +04:00
|
|
|
{
|
2012-01-25 20:00:40 +04:00
|
|
|
serverRandomLen = 32;
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
keyLen = settings->RdpServerRsaKey->ModulusLength;
|
|
|
|
expLen = sizeof(settings->RdpServerRsaKey->exponent);
|
2012-01-25 20:00:40 +04:00
|
|
|
wPublicKeyBlobLen = 4; /* magic (RSA1) */
|
|
|
|
wPublicKeyBlobLen += 4; /* keylen */
|
|
|
|
wPublicKeyBlobLen += 4; /* bitlen */
|
|
|
|
wPublicKeyBlobLen += 4; /* datalen */
|
|
|
|
wPublicKeyBlobLen += expLen;
|
|
|
|
wPublicKeyBlobLen += keyLen;
|
|
|
|
wPublicKeyBlobLen += 8; /* 8 bytes of zero padding */
|
|
|
|
|
|
|
|
serverCertLen = 4; /* dwVersion */
|
|
|
|
serverCertLen += 4; /* dwSigAlgId */
|
|
|
|
serverCertLen += 4; /* dwKeyAlgId */
|
|
|
|
serverCertLen += 2; /* wPublicKeyBlobType */
|
|
|
|
serverCertLen += 2; /* wPublicKeyBlobLen */
|
|
|
|
serverCertLen += wPublicKeyBlobLen;
|
|
|
|
serverCertLen += 2; /* wSignatureBlobType */
|
|
|
|
serverCertLen += 2; /* wSignatureBlobLen */
|
|
|
|
serverCertLen += sizeof(encryptedSignature); /* SignatureBlob */
|
|
|
|
serverCertLen += 8; /* 8 bytes of zero padding */
|
|
|
|
|
|
|
|
headerLen += sizeof(serverRandomLen);
|
|
|
|
headerLen += sizeof(serverCertLen);
|
|
|
|
headerLen += serverRandomLen;
|
|
|
|
headerLen += serverCertLen;
|
|
|
|
}
|
|
|
|
|
|
|
|
gcc_write_user_data_header(s, SC_SECURITY, headerLen);
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT32(s, settings->EncryptionMethods); /* encryptionMethod */
|
2012-11-07 20:02:46 +04:00
|
|
|
stream_write_UINT32(s, settings->EncryptionLevel); /* encryptionLevel */
|
2012-01-30 00:05:34 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE &&
|
2012-11-07 20:02:46 +04:00
|
|
|
settings->EncryptionLevel == ENCRYPTION_LEVEL_NONE)
|
2012-01-30 00:05:34 +04:00
|
|
|
{
|
2012-01-25 20:00:40 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, serverRandomLen); /* serverRandomLen */
|
|
|
|
stream_write_UINT32(s, serverCertLen); /* serverCertLen */
|
2012-01-25 20:00:40 +04:00
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
settings->ServerRandomLength = serverRandomLen;
|
|
|
|
settings->ServerRandom = (BYTE*) malloc(serverRandomLen);
|
|
|
|
crypto_nonce(settings->ServerRandom, serverRandomLen);
|
|
|
|
stream_write(s, settings->ServerRandom, serverRandomLen);
|
2012-01-25 20:00:40 +04:00
|
|
|
|
|
|
|
sigData = stream_get_tail(s);
|
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, CERT_CHAIN_VERSION_1); /* dwVersion (4 bytes) */
|
|
|
|
stream_write_UINT32(s, SIGNATURE_ALG_RSA); /* dwSigAlgId */
|
|
|
|
stream_write_UINT32(s, KEY_EXCHANGE_ALG_RSA); /* dwKeyAlgId */
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, BB_RSA_KEY_BLOB); /* wPublicKeyBlobType */
|
2012-01-25 20:00:40 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, wPublicKeyBlobLen); /* wPublicKeyBlobLen */
|
2012-01-25 20:00:40 +04:00
|
|
|
stream_write(s, "RSA1", 4); /* magic */
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, keyLen + 8); /* keylen */
|
|
|
|
stream_write_UINT32(s, keyLen * 8); /* bitlen */
|
|
|
|
stream_write_UINT32(s, keyLen - 1); /* datalen */
|
2012-01-25 20:00:40 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write(s, settings->RdpServerRsaKey->exponent, expLen);
|
|
|
|
stream_write(s, settings->RdpServerRsaKey->Modulus, keyLen);
|
2012-01-25 20:00:40 +04:00
|
|
|
stream_write_zero(s, 8);
|
|
|
|
|
|
|
|
sigDataLen = stream_get_tail(s) - sigData;
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, BB_RSA_SIGNATURE_BLOB); /* wSignatureBlobType */
|
|
|
|
stream_write_UINT16(s, keyLen + 8); /* wSignatureBlobLen */
|
2012-01-25 20:00:40 +04:00
|
|
|
|
|
|
|
memcpy(signature, initial_signature, sizeof(initial_signature));
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
md5 = crypto_md5_init();
|
|
|
|
crypto_md5_update(md5, sigData, sigDataLen);
|
|
|
|
crypto_md5_final(md5, signature);
|
|
|
|
|
|
|
|
crypto_rsa_private_encrypt(signature, sizeof(signature), TSSK_KEY_LENGTH,
|
|
|
|
tssk_modulus, tssk_privateExponent, encryptedSignature);
|
|
|
|
|
2012-01-25 20:00:40 +04:00
|
|
|
stream_write(s, encryptedSignature, sizeof(encryptedSignature));
|
|
|
|
stream_write_zero(s, 8);
|
2011-08-19 19:56:47 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a client network data block (TS_UD_CS_NET).\n
|
|
|
|
* @msdn{cc240512}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_client_network_data(STREAM* s, rdpSettings* settings, UINT16 blockLength)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2011-08-19 14:11:33 +04:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (blockLength < 4)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_read_UINT32(s, settings->ChannelCount); /* channelCount */
|
|
|
|
if (blockLength < 4 + settings->ChannelCount * 12)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->ChannelCount > 16)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
|
|
|
|
/* channelDefArray */
|
2012-11-08 08:29:24 +04:00
|
|
|
for (i = 0; i < settings->ChannelCount; i++)
|
2011-08-19 14:11:33 +04:00
|
|
|
{
|
|
|
|
/* CHANNEL_DEF */
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_read(s, settings->ChannelDefArray[i].Name, 8); /* name (8 bytes) */
|
|
|
|
stream_read_UINT32(s, settings->ChannelDefArray[i].options); /* options (4 bytes) */
|
|
|
|
settings->ChannelDefArray[i].ChannelId = MCS_GLOBAL_CHANNEL_ID + 1 + i;
|
2011-08-19 14:11:33 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 06:02:00 +04:00
|
|
|
/**
|
|
|
|
* Write a client network data block (TS_UD_CS_NET).\n
|
|
|
|
* @msdn{cc240512}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_client_network_data(STREAM* s, rdpSettings* settings)
|
2011-07-05 06:02:00 +04:00
|
|
|
{
|
2011-07-06 02:26:12 +04:00
|
|
|
int i;
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 length;
|
2011-07-05 06:02:00 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->ChannelCount > 0)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
length = settings->ChannelCount * 12 + 8;
|
2011-07-06 02:26:12 +04:00
|
|
|
gcc_write_user_data_header(s, CS_NET, length);
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT32(s, settings->ChannelCount); /* channelCount */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
|
|
|
/* channelDefArray */
|
2012-11-08 08:29:24 +04:00
|
|
|
for (i = 0; i < settings->ChannelCount; i++)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
|
|
|
/* CHANNEL_DEF */
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write(s, settings->ChannelDefArray[i].Name, 8); /* name (8 bytes) */
|
|
|
|
stream_write_UINT32(s, settings->ChannelDefArray[i].options); /* options (4 bytes) */
|
2011-07-06 02:26:12 +04:00
|
|
|
}
|
|
|
|
}
|
2011-07-05 06:02:00 +04:00
|
|
|
}
|
|
|
|
|
2012-10-09 10:38:39 +04:00
|
|
|
BOOL gcc_read_server_network_data(STREAM* s, rdpSettings* settings)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
|
|
|
int i;
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 MCSChannelId;
|
|
|
|
UINT16 channelCount;
|
|
|
|
UINT16 channelId;
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, MCSChannelId); /* MCSChannelId */
|
|
|
|
stream_read_UINT16(s, channelCount); /* channelCount */
|
2011-07-10 05:04:57 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (channelCount != settings->ChannelCount)
|
2011-07-10 05:04:57 +04:00
|
|
|
{
|
|
|
|
printf("requested %d channels, got %d instead\n",
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->ChannelCount, channelCount);
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < channelCount; i++)
|
|
|
|
{
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_read_UINT16(s, channelId); /* channelId */
|
2012-11-08 08:29:24 +04:00
|
|
|
settings->ChannelDefArray[i].ChannelId = channelId;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (channelCount % 2 == 1)
|
|
|
|
stream_seek(s, 2); /* padding */
|
2011-08-22 11:03:58 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-07-10 05:04:57 +04:00
|
|
|
}
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_server_network_data(STREAM* s, rdpSettings* settings)
|
2011-08-19 19:56:47 +04:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
gcc_write_user_data_header(s, SC_NET, 8 + settings->ChannelCount * 2 + (settings->ChannelCount % 2 == 1 ? 2 : 0));
|
2011-08-19 19:56:47 +04:00
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT16(s, settings->ChannelCount); /* channelCount */
|
2011-08-19 19:56:47 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
for (i = 0; i < settings->ChannelCount; i++)
|
2011-08-19 19:56:47 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT16(s, settings->ChannelDefArray[i].ChannelId);
|
2011-08-19 19:56:47 +04:00
|
|
|
}
|
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->ChannelCount % 2 == 1)
|
2012-10-09 11:01:37 +04:00
|
|
|
stream_write_UINT16(s, 0);
|
2011-08-19 19:56:47 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a client cluster data block (TS_UD_CS_CLUSTER).\n
|
|
|
|
* @msdn{cc240514}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_client_cluster_data(STREAM* s, rdpSettings* settings, UINT16 blockLength)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 flags;
|
2011-08-19 14:11:33 +04:00
|
|
|
|
|
|
|
if (blockLength < 8)
|
2012-10-09 10:31:28 +04:00
|
|
|
return FALSE;
|
2011-08-19 14:11:33 +04:00
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_read_UINT32(s, flags); /* flags */
|
2011-08-19 14:11:33 +04:00
|
|
|
|
2012-05-16 17:29:35 +04:00
|
|
|
if ((flags & REDIRECTED_SESSIONID_FIELD_VALID))
|
2012-11-08 00:13:14 +04:00
|
|
|
stream_read_UINT32(s, settings->RedirectedSessionId); /* redirectedSessionID */
|
2011-08-19 14:11:33 +04:00
|
|
|
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 06:02:00 +04:00
|
|
|
/**
|
|
|
|
* Write a client cluster data block (TS_UD_CS_CLUSTER).\n
|
|
|
|
* @msdn{cc240514}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_client_cluster_data(STREAM* s, rdpSettings* settings)
|
2011-07-05 06:02:00 +04:00
|
|
|
{
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 flags;
|
2011-07-06 02:26:12 +04:00
|
|
|
|
|
|
|
gcc_write_user_data_header(s, CS_CLUSTER, 12);
|
|
|
|
|
2011-07-08 08:37:25 +04:00
|
|
|
flags = REDIRECTION_SUPPORTED | (REDIRECTION_VERSION4 << 2);
|
2011-07-05 06:02:00 +04:00
|
|
|
|
2012-11-08 00:13:14 +04:00
|
|
|
if (settings->ConsoleSession || settings->RedirectedSessionId)
|
2011-07-06 02:26:12 +04:00
|
|
|
flags |= REDIRECTED_SESSIONID_FIELD_VALID;
|
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, flags); /* flags */
|
2012-11-08 00:13:14 +04:00
|
|
|
stream_write_UINT32(s, settings->RedirectedSessionId); /* redirectedSessionID */
|
2011-07-05 06:02:00 +04:00
|
|
|
}
|
|
|
|
|
2011-08-19 13:39:37 +04:00
|
|
|
/**
|
|
|
|
* Read a client monitor data block (TS_UD_CS_MONITOR).\n
|
|
|
|
* @msdn{dd305336}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-10-09 11:01:37 +04:00
|
|
|
BOOL gcc_read_client_monitor_data(STREAM* s, rdpSettings* settings, UINT16 blockLength)
|
2011-08-19 13:39:37 +04:00
|
|
|
{
|
|
|
|
printf("CS_MONITOR\n");
|
2012-10-09 10:31:28 +04:00
|
|
|
return TRUE;
|
2011-08-19 13:39:37 +04:00
|
|
|
}
|
|
|
|
|
2011-07-05 06:02:00 +04:00
|
|
|
/**
|
|
|
|
* Write a client monitor data block (TS_UD_CS_MONITOR).\n
|
|
|
|
* @msdn{dd305336}
|
|
|
|
* @param s stream
|
|
|
|
* @param settings rdp settings
|
|
|
|
*/
|
|
|
|
|
2012-01-30 00:05:34 +04:00
|
|
|
void gcc_write_client_monitor_data(STREAM* s, rdpSettings* settings)
|
2011-07-05 06:02:00 +04:00
|
|
|
{
|
2011-07-06 02:26:12 +04:00
|
|
|
int i;
|
2012-10-09 11:01:37 +04:00
|
|
|
UINT16 length;
|
2012-10-09 11:26:39 +04:00
|
|
|
UINT32 left, top, right, bottom, flags;
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
if (settings->MonitorCount > 1)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
length = (20 * settings->MonitorCount) + 12;
|
2011-07-06 02:26:12 +04:00
|
|
|
gcc_write_user_data_header(s, CS_MONITOR, length);
|
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, 0); /* flags */
|
2012-11-08 08:29:24 +04:00
|
|
|
stream_write_UINT32(s, settings->MonitorCount); /* monitorCount */
|
2011-07-06 02:26:12 +04:00
|
|
|
|
2012-11-08 08:29:24 +04:00
|
|
|
for (i = 0; i < settings->MonitorCount; i++)
|
2011-07-06 02:26:12 +04:00
|
|
|
{
|
2012-11-08 08:29:24 +04:00
|
|
|
left = settings->MonitorDefArray[i].x;
|
|
|
|
top = settings->MonitorDefArray[i].y;
|
|
|
|
right = settings->MonitorDefArray[i].x + settings->MonitorDefArray[i].width - 1;
|
|
|
|
bottom = settings->MonitorDefArray[i].y + settings->MonitorDefArray[i].height - 1;
|
|
|
|
flags = settings->MonitorDefArray[i].is_primary ? MONITOR_PRIMARY : 0;
|
2011-07-05 06:02:00 +04:00
|
|
|
|
2012-10-09 11:26:39 +04:00
|
|
|
stream_write_UINT32(s, left); /* left */
|
|
|
|
stream_write_UINT32(s, top); /* top */
|
|
|
|
stream_write_UINT32(s, right); /* right */
|
|
|
|
stream_write_UINT32(s, bottom); /* bottom */
|
|
|
|
stream_write_UINT32(s, flags); /* flags */
|
2011-07-06 02:26:12 +04:00
|
|
|
}
|
|
|
|
}
|
2011-07-05 06:02:00 +04:00
|
|
|
}
|