tpdu.c

 
#include <freerdp/config.h>
 
#include <stdio.h>
#include <winpr/print.h>
 
#include <freerdp/log.h>
 
#include "tpdu.h"
 
#define TAG FREERDP_TAG("core")
 
static BOOL tpdu_write_header(wStream* s, UINT16 length, BYTE code);
 
BOOL tpdu_read_header(wStream* s, BYTE* code, BYTE* li, UINT16 tpktlength)
{
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
    return FALSE;
 
  Stream_Read_UINT8(s, *li);   /* LI */
  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;
}
 
BOOL tpdu_write_header(wStream* s, UINT16 length, BYTE code)
{
  if (length > UINT8_MAX)
  {
    WLog_WARN(TAG, "tpdu invalid length, got %" PRIu16 ", maximum supported is %d", length,
              UINT8_MAX);
    return FALSE;
  }
  if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 3))
    return FALSE;
 
  WINPR_ASSERT(length <= UINT8_MAX);
  Stream_Write_UINT8(s, (UINT8)length); /* LI */
  Stream_Write_UINT8(s, code);   /* code */
 
  if (code == X224_TPDU_DATA)
  {
    Stream_Write_UINT8(s, 0x80); /* EOT */
  }
  else
  {
    if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 5))
      return FALSE;
    Stream_Write_UINT16(s, 0); /* DST-REF */
    Stream_Write_UINT16(s, 0); /* SRC-REF */
    Stream_Write_UINT8(s, 0);  /* Class 0 */
  }
  return TRUE;
}
 
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)
  {
    WLog_ERR(TAG, "Error: expected X224_TPDU_CONNECTION_REQUEST");
    return FALSE;
  }
 
  return TRUE;
}
 
BOOL tpdu_write_connection_request(wStream* s, UINT16 length)
{
  return tpdu_write_header(s, length, X224_TPDU_CONNECTION_REQUEST);
}
 
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)
  {
    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;
 
  return Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(*li - bytes_read));
}
 
BOOL tpdu_write_connection_confirm(wStream* s, UINT16 length)
{
  return tpdu_write_header(s, length, X224_TPDU_CONNECTION_CONFIRM);
}
 
BOOL tpdu_write_disconnect_request(wStream* s, UINT16 length)
{
  return tpdu_write_header(s, length, X224_TPDU_DISCONNECT_REQUEST);
}
 
BOOL tpdu_write_data(wStream* s)
{
  return tpdu_write_header(s, 2, X224_TPDU_DATA);
}
 
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)
  {
    const BYTE dCode = X224_TPDU_DATA;
    WLog_ERR(TAG, "tpdu got code 0x%02" PRIx8 " expected X224_TPDU_DATA [0x%02" PRIx8 "]", code,
             dCode);
    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";
  }
}