FreeRDP/libfreerdp/core/tpdu.c

285 lines
6.3 KiB
C
Raw Normal View History

/**
2012-10-09 07:02:04 +04:00
* FreeRDP: A Remote Desktop Protocol Implementation
* X.224 Transport Protocol Data Units (TPDUs)
*
* 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.
*/
2022-02-16 13:20:38 +03:00
#include <freerdp/config.h>
#include <stdio.h>
#include <winpr/print.h>
#include <freerdp/log.h>
#include "tpdu.h"
#define TAG FREERDP_TAG("core")
/**
* TPDUs are defined in:
*
* http://www.itu.int/rec/T-REC-X.224-199511-I/
2019-11-06 17:24:51 +03:00
* X.224: Information technology - Open Systems Interconnection - Protocol for providing the
* connection-mode transport service
*
* RDP uses only TPDUs of class 0, the "simple class" defined in section 8 of X.224
*
* TPDU Header
* ____________________ byte
* | |
* | LI | 1
* |____________________|
* | |
* | Code | 2
* |____________________|
* | |
* | | 3
* |_______DST-REF______|
* | |
* | | 4
* |____________________|
* | |
* | | 5
* |_______SRC-REF______|
* | |
* | | 6
* |____________________|
* | |
* | Class | 7
* |____________________|
* | ... |
*/
2022-10-10 12:22:20 +03:00
static BOOL tpdu_write_header(wStream* s, UINT16 length, BYTE code);
2019-11-20 13:30:14 +03:00
/**
* Read TPDU header.
* @param s stream
* @param code variable pointer to receive TPDU code
* @return TPDU length indicator (LI)
*/
BOOL tpdu_read_header(wStream* s, BYTE* code, BYTE* li, UINT16 tpktlength)
{
if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
return FALSE;
2019-11-06 17:24:51 +03:00
Stream_Read_UINT8(s, *li); /* LI */
2013-05-09 00:09:16 +04:00
Stream_Read_UINT8(s, *code); /* Code */
if (*li + 4 > tpktlength)
{
WLog_ERR(TAG, "tpdu length %" PRIu8 " > tpkt header length %" PRIu16, *li, tpktlength);
return FALSE;
}
if (*code == X224_TPDU_DATA)
{
/* EOT (1 byte) */
Stream_Seek(s, 1);
}
else
{
/* DST-REF (2 bytes) */
/* SRC-REF (2 bytes) */
/* Class 0 (1 byte) */
if (!Stream_SafeSeek(s, 5))
{
WLog_WARN(TAG, "tpdu invalid data, got %" PRIuz ", require at least 5 more",
Stream_GetRemainingLength(s));
return FALSE;
}
}
return TRUE;
}
/**
* Write TDPU header.
* @param s stream
* @param length length
* @param code TPDU code
*/
2022-10-10 12:22:20 +03:00
BOOL tpdu_write_header(wStream* s, UINT16 length, BYTE code)
{
2023-01-24 14:19:56 +03:00
if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 3))
2022-10-10 12:22:20 +03:00
return FALSE;
2013-05-09 00:09:16 +04:00
Stream_Write_UINT8(s, length); /* LI */
2019-11-06 17:24:51 +03:00
Stream_Write_UINT8(s, code); /* code */
if (code == X224_TPDU_DATA)
{
2013-05-09 00:09:16 +04:00
Stream_Write_UINT8(s, 0x80); /* EOT */
}
else
{
2023-01-24 14:19:56 +03:00
if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 5))
2022-10-10 12:22:20 +03:00
return FALSE;
2013-05-09 00:09:16 +04:00
Stream_Write_UINT16(s, 0); /* DST-REF */
Stream_Write_UINT16(s, 0); /* SRC-REF */
2019-11-06 17:24:51 +03:00
Stream_Write_UINT8(s, 0); /* Class 0 */
}
2022-10-10 12:22:20 +03:00
return TRUE;
}
/**
* Read Connection Request TPDU
* @param s stream
* @return length indicator (LI)
*/
BOOL tpdu_read_connection_request(wStream* s, BYTE* li, UINT16 tpktlength)
{
BYTE code = 0;
if (!tpdu_read_header(s, &code, li, tpktlength))
return FALSE;
if (code != X224_TPDU_CONNECTION_REQUEST)
{
2019-11-06 17:24:51 +03:00
WLog_ERR(TAG, "Error: expected X224_TPDU_CONNECTION_REQUEST");
return FALSE;
}
return TRUE;
}
/**
* Write Connection Request TPDU.
* @param s stream
* @param length TPDU length
*/
2022-10-10 12:22:20 +03:00
BOOL tpdu_write_connection_request(wStream* s, UINT16 length)
{
2022-10-10 12:22:20 +03:00
return tpdu_write_header(s, length, X224_TPDU_CONNECTION_REQUEST);
}
/**
* Read Connection Confirm TPDU.
* @param s stream
* @return length indicator (LI)
*/
BOOL tpdu_read_connection_confirm(wStream* s, BYTE* li, UINT16 tpktlength)
{
BYTE code = 0;
size_t position = 0;
size_t bytes_read = 0;
/* save the position to determine the number of bytes read */
position = Stream_GetPosition(s);
if (!tpdu_read_header(s, &code, li, tpktlength))
return FALSE;
if (code != X224_TPDU_CONNECTION_CONFIRM)
{
2019-11-06 17:24:51 +03:00
WLog_ERR(TAG, "Error: expected X224_TPDU_CONNECTION_CONFIRM");
return FALSE;
}
/*
* To ensure that there are enough bytes remaining for processing
* check against the length indicator (li). Already read bytes need
* to be taken into account.
* The -1 is because li was read but isn't included in the TPDU size.
* For reference see ITU-T Rec. X.224 - 13.2.1
*/
bytes_read = (Stream_GetPosition(s) - position) - 1;
if (!Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(*li - bytes_read)))
return FALSE;
return TRUE;
}
/**
* Write Connection Confirm TPDU.
* @param s stream
* @param length TPDU length
*/
2022-10-10 12:22:20 +03:00
BOOL tpdu_write_connection_confirm(wStream* s, UINT16 length)
{
2022-10-10 12:22:20 +03:00
return tpdu_write_header(s, length, X224_TPDU_CONNECTION_CONFIRM);
}
/**
* Write Disconnect Request TPDU.
* @param s stream
* @param length TPDU length
*/
2022-10-10 12:22:20 +03:00
BOOL tpdu_write_disconnect_request(wStream* s, UINT16 length)
{
2022-10-10 12:22:20 +03:00
return tpdu_write_header(s, length, X224_TPDU_DISCONNECT_REQUEST);
}
/**
* Write Data TPDU.
* @param s stream
*/
2022-10-10 12:22:20 +03:00
BOOL tpdu_write_data(wStream* s)
{
2022-10-10 12:22:20 +03:00
return tpdu_write_header(s, 2, X224_TPDU_DATA);
}
/**
* Read Data TPDU.
* @param s stream
*/
BOOL tpdu_read_data(wStream* s, UINT16* LI, UINT16 tpktlength)
{
BYTE code = 0;
BYTE li = 0;
if (!tpdu_read_header(s, &code, &li, tpktlength))
return FALSE;
if (code != X224_TPDU_DATA)
{
WLog_ERR(TAG, "tpdu got code 0x%02" PRIx8 " expected X224_TPDU_DATA [0x%02x]", code,
X224_TPDU_DATA);
return FALSE;
}
*LI = li;
return TRUE;
}
const char* tpdu_type_to_string(int type)
{
switch (type)
{
case X224_TPDU_CONNECTION_REQUEST:
return "X224_TPDU_CONNECTION_REQUEST";
case X224_TPDU_CONNECTION_CONFIRM:
return "X224_TPDU_CONNECTION_CONFIRM";
case X224_TPDU_DISCONNECT_REQUEST:
return "X224_TPDU_DISCONNECT_REQUEST";
case X224_TPDU_DATA:
return "X224_TPDU_DATA";
case X224_TPDU_ERROR:
return "X224_TPDU_ERROR";
default:
return "X224_TPDU_UNKNOWN";
}
}