/src/FreeRDP/libfreerdp/core/mcs.c

Source (jump to first uncovered line)
/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * T.125 Multipoint Communication Service (MCS) Protocol
 *
 * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2015 Thincast Technologies GmbH
 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
 * Copyright 2017 Armin Novak <armin.novak@thincast.com>
 * Copyright 2017 Thincast Technologies GmbH
 *
 * 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.
 */

#include <freerdp/config.h>

#include <winpr/crt.h>
#include <winpr/assert.h>
#include <freerdp/log.h>

#include "gcc.h"

#include "mcs.h"
#include "tpdu.h"
#include "tpkt.h"
#include "client.h"
#include "connection.h"

#define TAG FREERDP_TAG("core")

/**
 * T.125 MCS is defined in:
 *
 * http://www.itu.int/rec/T-REC-T.125-199802-I/
 * ITU-T T.125 Multipoint Communication Service Protocol Specification
 */

/**
 * Connect-Initial ::= [APPLICATION 101] IMPLICIT SEQUENCE
 * {
 *  callingDomainSelector   OCTET_STRING,
 *  calledDomainSelector    OCTET_STRING,
 *  upwardFlag      BOOLEAN,
 *  targetParameters    DomainParameters,
 *  minimumParameters   DomainParameters,
 *  maximumParameters   DomainParameters,
 *  userData      OCTET_STRING
 * }
 *
 * DomainParameters ::= SEQUENCE
 * {
 *  maxChannelIds     INTEGER (0..MAX),
 *  maxUserIds      INTEGER (0..MAX),
 *  maxTokenIds     INTEGER (0..MAX),
 *  numPriorities     INTEGER (0..MAX),
 *  minThroughput     INTEGER (0..MAX),
 *  maxHeight     INTEGER (0..MAX),
 *  maxMCSPDUsize     INTEGER (0..MAX),
 *  protocolVersion     INTEGER (0..MAX)
 * }
 *
 * Connect-Response ::= [APPLICATION 102] IMPLICIT SEQUENCE
 * {
 *  result        Result,
 *  calledConnectId     INTEGER (0..MAX),
 *  domainParameters    DomainParameters,
 *  userData      OCTET_STRING
 * }
 *
 * Result ::= ENUMERATED
 * {
 *  rt-successful     (0),
 *  rt-domain-merging   (1),
 *  rt-domain-not-hierarchical  (2),
 *  rt-no-such-channel    (3),
 *  rt-no-such-domain   (4),
 *  rt-no-such-user     (5),
 *  rt-not-admitted     (6),
 *  rt-other-user-id    (7),
 *  rt-parameters-unacceptable  (8),
 *  rt-token-not-available    (9),
 *  rt-token-not-possessed    (10),
 *  rt-too-many-channels    (11),
 *  rt-too-many-tokens    (12),
 *  rt-too-many-users   (13),
 *  rt-unspecified-failure    (14),
 *  rt-user-rejected    (15)
 * }
 *
 * ErectDomainRequest ::= [APPLICATION 1] IMPLICIT SEQUENCE
 * {
 *  subHeight     INTEGER (0..MAX),
 *  subInterval     INTEGER (0..MAX)
 * }
 *
 * AttachUserRequest ::= [APPPLICATION 10] IMPLICIT SEQUENCE
 * {
 * }
 *
 * AttachUserConfirm ::= [APPLICATION 11] IMPLICIT SEQUENCE
 * {
 *  result        Result,
 *  initiator     UserId OPTIONAL
 * }
 *
 * ChannelJoinRequest ::= [APPLICATION 14] IMPLICIT SEQUENCE
 * {
 *  initiator     UserId,
 *  channelId     ChannelId
 * }
 *
 * ChannelJoinConfirm ::= [APPLICATION 15] IMPLICIT SEQUENCE
 * {
 *  result        Result,
 *  initiator     UserId,
 *  requested     ChannelId,
 *  channelId     ChannelId OPTIONAL
 * }
 *
 * SendDataRequest ::= [APPLICATION 25] IMPLICIT SEQUENCE
 * {
 *  initiator     UserId,
 *  channelId     ChannelId,
 *  dataPriority      DataPriority,
 *  segmentation      Segmentation,
 *  userData      OCTET_STRING
 * }
 *
 * DataPriority ::= CHOICE
 * {
 *  top       NULL,
 *  high        NULL,
 *  medium        NULL,
 *  low       NULL,
 *  ...
 * }
 *
 * Segmentation ::= BIT_STRING
 * {
 *  begin       (0),
 *  end       (1)
 * } (SIZE(2))
 *
 * SendDataIndication ::= SEQUENCE
 * {
 *  initiator     UserId,
 *  channelId     ChannelId,
 *  reliability     BOOLEAN,
 *  domainReferenceID   INTEGER (0..65535) OPTIONAL,
 *  dataPriority      DataPriority,
 *  segmentation      Segmentation,
 *  userData      OCTET_STRING,
 *  totalDataSize     INTEGER OPTIONAL,
 *  nonStandard     SEQUENCE OF NonStandardParameter OPTIONAL,
 *  ...
 * }
 *
 */

static const BYTE callingDomainSelector[1] = "\x01";
static const BYTE calledDomainSelector[1] = "\x01";

/*
static const char* const mcs_result_enumerated[] =
{
        "rt-successful",
        "rt-domain-merging",
        "rt-domain-not-hierarchical",
        "rt-no-such-channel",
        "rt-no-such-domain",
        "rt-no-such-user",
        "rt-not-admitted",
        "rt-other-user-id",
        "rt-parameters-unacceptable",
        "rt-token-not-available",
        "rt-token-not-possessed",
        "rt-too-many-channels",
        "rt-too-many-tokens",
        "rt-too-many-users",
        "rt-unspecified-failure",
        "rt-user-rejected"
};
*/

const char* mcs_domain_pdu_string(DomainMCSPDU pdu)
{
  switch (pdu)
  {
    case DomainMCSPDU_PlumbDomainIndication:
      return "DomainMCSPDU_PlumbDomainIndication";
    case DomainMCSPDU_ErectDomainRequest:
      return "DomainMCSPDU_ErectDomainRequest";
    case DomainMCSPDU_MergeChannelsRequest:
      return "DomainMCSPDU_MergeChannelsRequest";
    case DomainMCSPDU_MergeChannelsConfirm:
      return "DomainMCSPDU_MergeChannelsConfirm";
    case DomainMCSPDU_PurgeChannelsIndication:
      return "DomainMCSPDU_PurgeChannelsIndication";
    case DomainMCSPDU_MergeTokensRequest:
      return "DomainMCSPDU_MergeTokensRequest";
    case DomainMCSPDU_MergeTokensConfirm:
      return "DomainMCSPDU_MergeTokensConfirm";
    case DomainMCSPDU_PurgeTokensIndication:
      return "DomainMCSPDU_PurgeTokensIndication";
    case DomainMCSPDU_DisconnectProviderUltimatum:
      return "DomainMCSPDU_DisconnectProviderUltimatum";
    case DomainMCSPDU_RejectMCSPDUUltimatum:
      return "DomainMCSPDU_RejectMCSPDUUltimatum";
    case DomainMCSPDU_AttachUserRequest:
      return "DomainMCSPDU_AttachUserRequest";
    case DomainMCSPDU_AttachUserConfirm:
      return "DomainMCSPDU_AttachUserConfirm";
    case DomainMCSPDU_DetachUserRequest:
      return "DomainMCSPDU_DetachUserRequest";
    case DomainMCSPDU_DetachUserIndication:
      return "DomainMCSPDU_DetachUserIndication";
    case DomainMCSPDU_ChannelJoinRequest:
      return "DomainMCSPDU_ChannelJoinRequest";
    case DomainMCSPDU_ChannelJoinConfirm:
      return "DomainMCSPDU_ChannelJoinConfirm";
    case DomainMCSPDU_ChannelLeaveRequest:
      return "DomainMCSPDU_ChannelLeaveRequest";
    case DomainMCSPDU_ChannelConveneRequest:
      return "DomainMCSPDU_ChannelConveneRequest";
    case DomainMCSPDU_ChannelConveneConfirm:
      return "DomainMCSPDU_ChannelConveneConfirm";
    case DomainMCSPDU_ChannelDisbandRequest:
      return "DomainMCSPDU_ChannelDisbandRequest";
    case DomainMCSPDU_ChannelDisbandIndication:
      return "DomainMCSPDU_ChannelDisbandIndication";
    case DomainMCSPDU_ChannelAdmitRequest:
      return "DomainMCSPDU_ChannelAdmitRequest";
    case DomainMCSPDU_ChannelAdmitIndication:
      return "DomainMCSPDU_ChannelAdmitIndication";
    case DomainMCSPDU_ChannelExpelRequest:
      return "DomainMCSPDU_ChannelExpelRequest";
    case DomainMCSPDU_ChannelExpelIndication:
      return "DomainMCSPDU_ChannelExpelIndication";
    case DomainMCSPDU_SendDataRequest:
      return "DomainMCSPDU_SendDataRequest";
    case DomainMCSPDU_SendDataIndication:
      return "DomainMCSPDU_SendDataIndication";
    case DomainMCSPDU_UniformSendDataRequest:
      return "DomainMCSPDU_UniformSendDataRequest";
    case DomainMCSPDU_UniformSendDataIndication:
      return "DomainMCSPDU_UniformSendDataIndication";
    case DomainMCSPDU_TokenGrabRequest:
      return "DomainMCSPDU_TokenGrabRequest";
    case DomainMCSPDU_TokenGrabConfirm:
      return "DomainMCSPDU_TokenGrabConfirm";
    case DomainMCSPDU_TokenInhibitRequest:
      return "DomainMCSPDU_TokenInhibitRequest";
    case DomainMCSPDU_TokenInhibitConfirm:
      return "DomainMCSPDU_TokenInhibitConfirm";
    case DomainMCSPDU_TokenGiveRequest:
      return "DomainMCSPDU_TokenGiveRequest";
    case DomainMCSPDU_TokenGiveIndication:
      return "DomainMCSPDU_TokenGiveIndication";
    case DomainMCSPDU_TokenGiveResponse:
      return "DomainMCSPDU_TokenGiveResponse";
    case DomainMCSPDU_TokenGiveConfirm:
      return "DomainMCSPDU_TokenGiveConfirm";
    case DomainMCSPDU_TokenPleaseRequest:
      return "DomainMCSPDU_TokenPleaseRequest";
    case DomainMCSPDU_TokenPleaseConfirm:
      return "DomainMCSPDU_TokenPleaseConfirm";
    case DomainMCSPDU_TokenReleaseRequest:
      return "DomainMCSPDU_TokenReleaseRequest";
    case DomainMCSPDU_TokenReleaseConfirm:
      return "DomainMCSPDU_TokenReleaseConfirm";
    case DomainMCSPDU_TokenTestRequest:
      return "DomainMCSPDU_TokenTestRequest";
    case DomainMCSPDU_TokenTestConfirm:
      return "DomainMCSPDU_TokenTestConfirm";
    case DomainMCSPDU_enum_length:
      return "DomainMCSPDU_enum_length";
    default:
      return "DomainMCSPDU_UNKNOWN";
  }
}

static BOOL mcs_merge_domain_parameters(DomainParameters* targetParameters,
                                        DomainParameters* minimumParameters,
                                        DomainParameters* maximumParameters,
                                        DomainParameters* pOutParameters);

static BOOL mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData);
static BOOL mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData);
static BOOL mcs_read_domain_mcspdu_header(wStream* s, DomainMCSPDU domainMCSPDU, UINT16* length,
                                          DomainMCSPDU* actual);

static int mcs_initialize_client_channels(rdpMcs* mcs, const rdpSettings* settings)
{
  if (!mcs || !settings)
    return -1;

  mcs->channelCount = freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount);

  if (mcs->channelCount > mcs->channelMaxCount)
    mcs->channelCount = mcs->channelMaxCount;

  ZeroMemory(mcs->channels, sizeof(rdpMcsChannel) * mcs->channelMaxCount);

  for (UINT32 index = 0; index < mcs->channelCount; index++)
  {
    const CHANNEL_DEF* defchannel =
        freerdp_settings_get_pointer_array(settings, FreeRDP_ChannelDefArray, index);
    rdpMcsChannel* cur = &mcs->channels[index];
    WINPR_ASSERT(defchannel);
    CopyMemory(cur->Name, defchannel->name, CHANNEL_NAME_LEN);
    cur->options = defchannel->options;
  }

  return 0;
}

/**
 * Read a DomainMCSPDU header.
 * @param s stream
 * @param domainMCSPDU DomainMCSPDU type
 * @param length TPKT length
 *
 * @return \b TRUE for success, \b FALSE otherwise
 */

BOOL mcs_read_domain_mcspdu_header(wStream* s, DomainMCSPDU domainMCSPDU, UINT16* length,
                                   DomainMCSPDU* actual)
{
  UINT16 li = 0;
  BYTE choice = 0;

  if (actual)
    *actual = DomainMCSPDU_invalid;

  WINPR_ASSERT(s);
  WINPR_ASSERT(domainMCSPDU);
  WINPR_ASSERT(length);

  if (!tpkt_read_header(s, length))
    return FALSE;

  if (!tpdu_read_data(s, &li, *length))
    return FALSE;

  if (!per_read_choice(s, &choice))
    return FALSE;

  const DomainMCSPDU MCSPDU = (choice >> 2);
  if (actual)
    *actual = MCSPDU;

  if (domainMCSPDU != MCSPDU)
  {
    WLog_ERR(TAG, "Expected MCS %s, got %s", mcs_domain_pdu_string(domainMCSPDU),
             mcs_domain_pdu_string(MCSPDU));
    return FALSE;
  }

  return TRUE;
}

/**
 * Write a DomainMCSPDU header.
 * @param s stream
 * @param domainMCSPDU DomainMCSPDU type
 * @param length TPKT length
 */

BOOL mcs_write_domain_mcspdu_header(wStream* s, DomainMCSPDU domainMCSPDU, UINT16 length,
                                    BYTE options)
{
  WINPR_ASSERT(s);
  WINPR_ASSERT((options & ~0x03) == 0);
  WINPR_ASSERT((domainMCSPDU & ~0x3F) == 0);

  if (!tpkt_write_header(s, length))
    return FALSE;
  if (!tpdu_write_data(s))
    return FALSE;
  return per_write_choice(s, (BYTE)((domainMCSPDU << 2) | options));
}

/**
 * Initialize MCS Domain Parameters.
 * @param domainParameters domain parameters
 * @param maxChannelIds max channel ids
 * @param maxUserIds max user ids
 * @param maxTokenIds max token ids
 * @param maxMCSPDUsize max MCS PDU size
 */

static BOOL mcs_init_domain_parameters(DomainParameters* domainParameters, UINT32 maxChannelIds,
                                       UINT32 maxUserIds, UINT32 maxTokenIds, UINT32 maxMCSPDUsize)
{
  if (!domainParameters)
    return FALSE;

  domainParameters->maxChannelIds = maxChannelIds;
  domainParameters->maxUserIds = maxUserIds;
  domainParameters->maxTokenIds = maxTokenIds;
  domainParameters->maxMCSPDUsize = maxMCSPDUsize;
  domainParameters->numPriorities = 1;
  domainParameters->minThroughput = 0;
  domainParameters->maxHeight = 1;
  domainParameters->protocolVersion = 2;
  return TRUE;
}

/**
 * Read MCS Domain Parameters.
 * @param s stream
 * @param domainParameters domain parameters
 */

static BOOL mcs_read_domain_parameters(wStream* s, DomainParameters* domainParameters)
{
  size_t length = 0;

  if (!s || !domainParameters)
    return FALSE;

  return ber_read_sequence_tag(s, &length) &&
         ber_read_integer(s, &(domainParameters->maxChannelIds)) &&
         ber_read_integer(s, &(domainParameters->maxUserIds)) &&
         ber_read_integer(s, &(domainParameters->maxTokenIds)) &&
         ber_read_integer(s, &(domainParameters->numPriorities)) &&
         ber_read_integer(s, &(domainParameters->minThroughput)) &&
         ber_read_integer(s, &(domainParameters->maxHeight)) &&
         ber_read_integer(s, &(domainParameters->maxMCSPDUsize)) &&
         ber_read_integer(s, &(domainParameters->protocolVersion));
}

/**
 * Write MCS Domain Parameters.
 * @param s stream
 * @param domainParameters domain parameters
 */

static BOOL mcs_write_domain_parameters(wStream* s, DomainParameters* domainParameters)
{
  size_t length = 0;
  wStream* tmps = NULL;

  if (!s || !domainParameters)
    return FALSE;

  tmps = Stream_New(NULL, Stream_Capacity(s));

  if (!tmps)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  ber_write_integer(tmps, domainParameters->maxChannelIds);
  ber_write_integer(tmps, domainParameters->maxUserIds);
  ber_write_integer(tmps, domainParameters->maxTokenIds);
  ber_write_integer(tmps, domainParameters->numPriorities);
  ber_write_integer(tmps, domainParameters->minThroughput);
  ber_write_integer(tmps, domainParameters->maxHeight);
  ber_write_integer(tmps, domainParameters->maxMCSPDUsize);
  ber_write_integer(tmps, domainParameters->protocolVersion);
  length = Stream_GetPosition(tmps);
  ber_write_sequence_tag(s, length);
  Stream_Write(s, Stream_Buffer(tmps), length);
  Stream_Free(tmps, TRUE);
  return TRUE;
}

#ifdef DEBUG_MCS
/**
 * Print MCS Domain Parameters.
 * @param domainParameters domain parameters
 */

static void mcs_print_domain_parameters(DomainParameters* domainParameters)
{
  WLog_INFO(TAG, "DomainParameters {");

  if (domainParameters)
  {
    WLog_INFO(TAG, "\tmaxChannelIds:%" PRIu32 "", domainParameters->maxChannelIds);
    WLog_INFO(TAG, "\tmaxUserIds:%" PRIu32 "", domainParameters->maxUserIds);
    WLog_INFO(TAG, "\tmaxTokenIds:%" PRIu32 "", domainParameters->maxTokenIds);
    WLog_INFO(TAG, "\tnumPriorities:%" PRIu32 "", domainParameters->numPriorities);
    WLog_INFO(TAG, "\tminThroughput:%" PRIu32 "", domainParameters->minThroughput);
    WLog_INFO(TAG, "\tmaxHeight:%" PRIu32 "", domainParameters->maxHeight);
    WLog_INFO(TAG, "\tmaxMCSPDUsize:%" PRIu32 "", domainParameters->maxMCSPDUsize);
    WLog_INFO(TAG, "\tprotocolVersion:%" PRIu32 "", domainParameters->protocolVersion);
  }
  else
    WLog_INFO(TAG, "\tdomainParameters=%p", domainParameters);

  WLog_INFO(TAG, "}");
}
#endif

/**
 * Merge MCS Domain Parameters.
 * @param targetParameters target parameters
 * @param minimumParameters minimum parameters
 * @param maximumParameters maximum parameters
 * @param pOutParameters output parameters
 *
 * @return \b TRUE for success, \b FALSE otherwise
 */

BOOL mcs_merge_domain_parameters(DomainParameters* targetParameters,
                                 DomainParameters* minimumParameters,
                                 DomainParameters* maximumParameters,
                                 DomainParameters* pOutParameters)
{
  /* maxChannelIds */
  if (!targetParameters || !minimumParameters || !maximumParameters || !pOutParameters)
    return FALSE;

  if (targetParameters->maxChannelIds >= 4)
  {
    pOutParameters->maxChannelIds = targetParameters->maxChannelIds;
  }
  else if (maximumParameters->maxChannelIds >= 4)
  {
    pOutParameters->maxChannelIds = 4;
  }
  else
  {
    WLog_ERR(TAG, "invalid maxChannelIds [%" PRIu32 ", %" PRIu32 "]",
             targetParameters->maxChannelIds, maximumParameters->maxChannelIds);
    return FALSE;
  }

  /* maxUserIds */

  if (targetParameters->maxUserIds >= 3)
  {
    pOutParameters->maxUserIds = targetParameters->maxUserIds;
  }
  else if (maximumParameters->maxUserIds >= 3)
  {
    pOutParameters->maxUserIds = 3;
  }
  else
  {
    WLog_ERR(TAG, "invalid maxUserIds [%" PRIu32 ", %" PRIu32 "]", targetParameters->maxUserIds,
             maximumParameters->maxUserIds);
    return FALSE;
  }

  /* maxTokenIds */
  pOutParameters->maxTokenIds = targetParameters->maxTokenIds;

  /* numPriorities */

  if (minimumParameters->numPriorities <= 1)
  {
    pOutParameters->numPriorities = 1;
  }
  else
  {
    WLog_ERR(TAG, "invalid numPriorities [%" PRIu32 "]", maximumParameters->numPriorities);
    return FALSE;
  }

  /* minThroughput */
  pOutParameters->minThroughput = targetParameters->minThroughput;

  /* maxHeight */

  if ((targetParameters->maxHeight == 1) || (minimumParameters->maxHeight <= 1))
  {
    pOutParameters->maxHeight = 1;
  }
  else
  {
    WLog_ERR(TAG, "invalid maxHeight [%" PRIu32 ", %" PRIu32 "]", targetParameters->maxHeight,
             minimumParameters->maxHeight);
    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
    {
      WLog_ERR(TAG, "invalid maxMCSPDUsize [%" PRIu32 ", %" PRIu32 "]",
               targetParameters->maxMCSPDUsize, minimumParameters->maxMCSPDUsize);
      return FALSE;
    }
  }
  else
  {
    if (maximumParameters->maxMCSPDUsize >= 124)
    {
      pOutParameters->maxMCSPDUsize = maximumParameters->maxMCSPDUsize;
    }
    else
    {
      WLog_ERR(TAG, "invalid maxMCSPDUsize [%" PRIu32 "]", maximumParameters->maxMCSPDUsize);
      return FALSE;
    }
  }

  /* protocolVersion */

  if ((targetParameters->protocolVersion == 2) ||
      ((minimumParameters->protocolVersion <= 2) && (maximumParameters->protocolVersion >= 2)))
  {
    pOutParameters->protocolVersion = 2;
  }
  else
  {
    WLog_ERR(TAG, "invalid protocolVersion [%" PRIu32 ", %" PRIu32 ", %" PRIu32 "]",
             targetParameters->protocolVersion, minimumParameters->protocolVersion,
             maximumParameters->protocolVersion);
    return FALSE;
  }

  return TRUE;
}

/**
 * Read an MCS Connect Initial PDU.
 * msdn{cc240508}
 * @param mcs MCS module
 * @param s stream
 */

BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s)
{
  UINT16 li = 0;
  size_t length = 0;
  BOOL upwardFlag = FALSE;
  UINT16 tlength = 0;

  WINPR_ASSERT(mcs);
  WINPR_ASSERT(s);

  if (!tpkt_read_header(s, &tlength))
    return FALSE;

  if (!tpdu_read_data(s, &li, tlength))
    return FALSE;

  if (!ber_read_application_tag(s, MCS_TYPE_CONNECT_INITIAL, &length))
    return FALSE;

  /* callingDomainSelector (OCTET_STRING) */
  if (!ber_read_octet_string_tag(s, &length) ||
      (!Stream_CheckAndLogRequiredLength(TAG, s, length)))
    return FALSE;

  Stream_Seek(s, length);

  /* calledDomainSelector (OCTET_STRING) */
  if (!ber_read_octet_string_tag(s, &length) ||
      (!Stream_CheckAndLogRequiredLength(TAG, s, length)))
    return FALSE;

  Stream_Seek(s, length);

  /* upwardFlag (BOOLEAN) */
  if (!ber_read_BOOL(s, &upwardFlag))
    return FALSE;

  /* targetParameters (DomainParameters) */
  if (!mcs_read_domain_parameters(s, &mcs->targetParameters))
    return FALSE;

  /* minimumParameters (DomainParameters) */
  if (!mcs_read_domain_parameters(s, &mcs->minimumParameters))
    return FALSE;

  /* maximumParameters (DomainParameters) */
  if (!mcs_read_domain_parameters(s, &mcs->maximumParameters))
    return FALSE;

  if (!ber_read_octet_string_tag(s, &length) ||
      (!Stream_CheckAndLogRequiredLength(TAG, s, length)))
    return FALSE;

  if (!gcc_read_conference_create_request(s, mcs))
    return FALSE;

  if (!mcs_merge_domain_parameters(&mcs->targetParameters, &mcs->minimumParameters,
                                   &mcs->maximumParameters, &mcs->domainParameters))
    return FALSE;

  return tpkt_ensure_stream_consumed(s, tlength);
}

/**
 * Write an MCS Connect Initial PDU.
 * msdn{cc240508}
 * @param s stream
 * @param mcs MCS module
 * @param userData GCC Conference Create Request
 */

BOOL mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData)
{
  size_t length = 0;
  wStream* tmps = NULL;
  BOOL ret = FALSE;

  if (!s || !mcs || !userData)
    return FALSE;

  tmps = Stream_New(NULL, Stream_Capacity(s));

  if (!tmps)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  /* callingDomainSelector (OCTET_STRING) */
  ber_write_octet_string(tmps, callingDomainSelector, sizeof(callingDomainSelector));
  /* calledDomainSelector (OCTET_STRING) */
  ber_write_octet_string(tmps, calledDomainSelector, sizeof(calledDomainSelector));
  /* upwardFlag (BOOLEAN) */
  ber_write_BOOL(tmps, TRUE);

  /* targetParameters (DomainParameters) */
  if (!mcs_write_domain_parameters(tmps, &mcs->targetParameters))
    goto out;

  /* minimumParameters (DomainParameters) */
  if (!mcs_write_domain_parameters(tmps, &mcs->minimumParameters))
    goto out;

  /* maximumParameters (DomainParameters) */
  if (!mcs_write_domain_parameters(tmps, &mcs->maximumParameters))
    goto out;

  /* userData (OCTET_STRING) */
  ber_write_octet_string(tmps, Stream_Buffer(userData), Stream_GetPosition(userData));
  length = Stream_GetPosition(tmps);
  /* Connect-Initial (APPLICATION 101, IMPLICIT SEQUENCE) */
  ber_write_application_tag(s, MCS_TYPE_CONNECT_INITIAL, length);
  Stream_Write(s, Stream_Buffer(tmps), length);
  ret = TRUE;
out:
  Stream_Free(tmps, TRUE);
  return ret;
}

/**
 * Write an MCS Connect Response PDU.
 * msdn{cc240508}
 * @param s stream
 * @param mcs MCS module
 * @param userData GCC Conference Create Response
 *
 * @return \b TRUE for success, \b FALSE otherwise
 */

BOOL mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData)
{
  size_t length = 0;
  wStream* tmps = NULL;
  BOOL ret = FALSE;

  if (!s || !mcs || !userData)
    return FALSE;

  tmps = Stream_New(NULL, Stream_Capacity(s));

  if (!tmps)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  ber_write_enumerated(tmps, 0, MCS_Result_enum_length);
  ber_write_integer(tmps, 0); /* calledConnectId */

  if (!mcs_write_domain_parameters(tmps, &(mcs->domainParameters)))
    goto out;

  /* userData (OCTET_STRING) */
  ber_write_octet_string(tmps, Stream_Buffer(userData), Stream_GetPosition(userData));
  length = Stream_GetPosition(tmps);
  ber_write_application_tag(s, MCS_TYPE_CONNECT_RESPONSE, length);
  Stream_Write(s, Stream_Buffer(tmps), length);
  ret = TRUE;
out:
  Stream_Free(tmps, TRUE);
  return ret;
}

/**
 * Send MCS Connect Initial.
 * msdn{cc240508}
 * @param mcs mcs module
 */

static BOOL mcs_send_connect_initial(rdpMcs* mcs)
{
  int status = -1;
  size_t length = 0;
  wStream* s = NULL;
  size_t bm = 0;
  size_t em = 0;
  wStream* gcc_CCrq = NULL;
  wStream* client_data = NULL;
  rdpContext* context = NULL;

  if (!mcs)
    return FALSE;

  context = transport_get_context(mcs->transport);
  WINPR_ASSERT(context);

  mcs_initialize_client_channels(mcs, context->settings);
  client_data = Stream_New(NULL, 512);

  if (!client_data)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  if (!gcc_write_client_data_blocks(client_data, mcs))
    goto out;
  gcc_CCrq = Stream_New(NULL, 1024);

  if (!gcc_CCrq)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    goto out;
  }

  if (!gcc_write_conference_create_request(gcc_CCrq, client_data))
    goto out;
  length = Stream_GetPosition(gcc_CCrq) + 7;
  s = Stream_New(NULL, 1024 + length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    goto out;
  }

  bm = Stream_GetPosition(s);
  Stream_Seek(s, 7);

  if (!mcs_write_connect_initial(s, mcs, gcc_CCrq))
  {
    WLog_ERR(TAG, "mcs_write_connect_initial failed!");
    goto out;
  }

  em = Stream_GetPosition(s);
  length = (em - bm);
  if (length > UINT16_MAX)
    goto out;
  Stream_SetPosition(s, bm);
  if (!tpkt_write_header(s, (UINT16)length))
    goto out;
  if (!tpdu_write_data(s))
    goto out;
  Stream_SetPosition(s, em);
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
out:
  Stream_Free(s, TRUE);
  Stream_Free(gcc_CCrq, TRUE);
  Stream_Free(client_data, TRUE);
  return (status < 0 ? FALSE : TRUE);
}

/**
 * Read MCS Connect Response.
 * msdn{cc240501}
 * @param mcs mcs module
 */

BOOL mcs_recv_connect_response(rdpMcs* mcs, wStream* s)
{
  size_t length = 0;
  UINT16 tlength = 0;
  BYTE result = 0;
  UINT16 li = 0;
  UINT32 calledConnectId = 0;

  if (!mcs || !s)
    return FALSE;

  if (!tpkt_read_header(s, &tlength))
    return FALSE;

  if (!tpdu_read_data(s, &li, tlength))
    return FALSE;

  if (!ber_read_application_tag(s, MCS_TYPE_CONNECT_RESPONSE, &length) ||
      !ber_read_enumerated(s, &result, MCS_Result_enum_length) ||
      !ber_read_integer(s, &calledConnectId) ||
      !mcs_read_domain_parameters(s, &(mcs->domainParameters)) ||
      !ber_read_octet_string_tag(s, &length))
  {
    return FALSE;
  }

  if (!gcc_read_conference_create_response(s, mcs))
  {
    WLog_ERR(TAG, "gcc_read_conference_create_response failed");
    return FALSE;
  }

  return tpkt_ensure_stream_consumed(s, tlength);
}

/**
 * Send MCS Connect Response.
 * msdn{cc240501}
 * @param mcs mcs module
 */

BOOL mcs_send_connect_response(rdpMcs* mcs)
{
  size_t length = 0;
  int status = -1;
  wStream* s = NULL;
  size_t bm = 0;
  size_t em = 0;
  wStream* gcc_CCrsp = NULL;
  wStream* server_data = NULL;

  if (!mcs)
    return FALSE;

  server_data = Stream_New(NULL, 512);

  if (!server_data)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  if (!gcc_write_server_data_blocks(server_data, mcs))
    goto out;

  gcc_CCrsp = Stream_New(NULL, 512 + Stream_Capacity(server_data));

  if (!gcc_CCrsp)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    goto out;
  }

  if (!gcc_write_conference_create_response(gcc_CCrsp, server_data))
    goto out;
  length = Stream_GetPosition(gcc_CCrsp) + 7;
  s = Stream_New(NULL, length + 1024);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    goto out;
  }

  bm = Stream_GetPosition(s);
  Stream_Seek(s, 7);

  if (!mcs_write_connect_response(s, mcs, gcc_CCrsp))
    goto out;

  em = Stream_GetPosition(s);
  length = (em - bm);
  if (length > UINT16_MAX)
    goto out;
  Stream_SetPosition(s, bm);
  if (!tpkt_write_header(s, (UINT16)length))
    goto out;
  if (!tpdu_write_data(s))
    goto out;
  Stream_SetPosition(s, em);
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
out:
  Stream_Free(s, TRUE);
  Stream_Free(gcc_CCrsp, TRUE);
  Stream_Free(server_data, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Read MCS Erect Domain Request.
 * msdn{cc240523}
 * @param mcs MCS module to use
 * @param s stream
 */

BOOL mcs_recv_erect_domain_request(rdpMcs* mcs, wStream* s)
{
  UINT16 length = 0;
  UINT32 subHeight = 0;
  UINT32 subInterval = 0;

  WINPR_ASSERT(mcs);
  WINPR_ASSERT(s);

  if (!mcs_read_domain_mcspdu_header(s, DomainMCSPDU_ErectDomainRequest, &length, NULL))
    return FALSE;

  if (!per_read_integer(s, &subHeight)) /* subHeight (INTEGER) */
    return FALSE;

  if (!per_read_integer(s, &subInterval)) /* subInterval (INTEGER) */
    return FALSE;

  return tpkt_ensure_stream_consumed(s, length);
}

/**
 * Send MCS Erect Domain Request.
 * msdn{cc240523}
 * @param mcs MCS module to use
 */

BOOL mcs_send_erect_domain_request(rdpMcs* mcs)
{
  wStream* s = NULL;
  int status = 0;
  UINT16 length = 12;

  if (!mcs)
    return FALSE;

  s = Stream_New(NULL, length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ErectDomainRequest, length, 0);
  per_write_integer(s, 0); /* subHeight (INTEGER) */
  per_write_integer(s, 0); /* subInterval (INTEGER) */
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Read MCS Attach User Request.
 * msdn{cc240524}
 * @param mcs mcs module
 * @param s stream
 */

BOOL mcs_recv_attach_user_request(rdpMcs* mcs, wStream* s)
{
  UINT16 length = 0;

  if (!mcs || !s)
    return FALSE;

  if (!mcs_read_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, &length, NULL))
    return FALSE;
  return tpkt_ensure_stream_consumed(s, length);
}

/**
 * Send MCS Attach User Request.
 * msdn{cc240524}
 * @param mcs mcs module
 */

BOOL mcs_send_attach_user_request(rdpMcs* mcs)
{
  wStream* s = NULL;
  int status = 0;
  UINT16 length = 8;

  if (!mcs)
    return FALSE;

  s = Stream_New(NULL, length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, length, 0);
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Read MCS Attach User Confirm.
 * msdn{cc240525}
 * @param mcs mcs module
 */

BOOL mcs_recv_attach_user_confirm(rdpMcs* mcs, wStream* s)
{
  BYTE result = 0;
  UINT16 length = 0;

  if (!mcs || !s)
    return FALSE;

  if (!mcs_read_domain_mcspdu_header(s, DomainMCSPDU_AttachUserConfirm, &length, NULL))
    return FALSE;
  if (!per_read_enumerated(s, &result, MCS_Result_enum_length)) /* result */
    return FALSE;
  if (!per_read_integer16(s, &(mcs->userId), MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
    return FALSE;
  return tpkt_ensure_stream_consumed(s, length);
}

/**
 * Send MCS Attach User Confirm.
 * msdn{cc240525}
 * @param mcs mcs module
 */

BOOL mcs_send_attach_user_confirm(rdpMcs* mcs)
{
  wStream* s = NULL;
  int status = 0;
  UINT16 length = 11;

  if (!mcs)
    return FALSE;

  s = Stream_New(NULL, length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  mcs->userId = mcs->baseChannelId++;
  mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserConfirm, length, 2);
  per_write_enumerated(s, 0, MCS_Result_enum_length);       /* result */
  per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Read MCS Channel Join Request.
 * msdn{cc240526}
 * @param mcs mcs module
 * @param s stream
 */

BOOL mcs_recv_channel_join_request(rdpMcs* mcs, const rdpSettings* settings, wStream* s,
                                   UINT16* channelId)
{
  UINT16 length = 0;
  UINT16 userId = 0;

  if (!mcs || !s || !channelId)
    return FALSE;

  if (!mcs_read_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinRequest, &length, NULL))
    return FALSE;

  if (!per_read_integer16(s, &userId, MCS_BASE_CHANNEL_ID))
    return FALSE;
  if (userId != mcs->userId)
  {
    if (freerdp_settings_get_bool(settings, FreeRDP_TransportDumpReplay))
      mcs->userId = userId;
    else
      return FALSE;
  }
  if (!per_read_integer16(s, channelId, 0))
    return FALSE;

  return tpkt_ensure_stream_consumed(s, length);
}

/**
 * Send MCS Channel Join Request.
 * msdn{cc240526}
 *
 * @param mcs mcs module
 * @param channelId channel id
 *
 * @return \b TRUE for success, \b FALSE otherwise
 */

BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channelId)
{
  wStream* s = NULL;
  int status = 0;
  UINT16 length = 12;

  WINPR_ASSERT(mcs);

  s = Stream_New(NULL, length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinRequest, length, 0);
  per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID);
  per_write_integer16(s, channelId, 0);
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Read MCS Channel Join Confirm.
 * msdn{cc240527}
 * @param mcs mcs module
 */

BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channelId)
{
  UINT16 length = 0;
  BYTE result = 0;
  UINT16 initiator = 0;
  UINT16 requested = 0;

  WINPR_ASSERT(mcs);
  WINPR_ASSERT(channelId);

  if (!mcs_read_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinConfirm, &length, NULL))
    return FALSE;

  if (!per_read_enumerated(s, &result, MCS_Result_enum_length)) /* result */
    return FALSE;
  if (!per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
    return FALSE;
  if (!per_read_integer16(s, &requested, 0)) /* requested (ChannelId) */
    return FALSE;
  if (!per_read_integer16(s, channelId, 0)) /* channelId */
    return FALSE;
  return tpkt_ensure_stream_consumed(s, length);
}

/**
 * Send MCS Channel Join Confirm.
 * msdn{cc240527}
 * @param mcs mcs module
 */

BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channelId)
{
  wStream* s = NULL;
  int status = -1;
  UINT16 length = 15;

  if (!mcs)
    return FALSE;

  s = Stream_New(NULL, length);

  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return FALSE;
  }

  if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinConfirm, length, 2))
    goto fail;
  if (!per_write_enumerated(s, 0, MCS_Result_enum_length)) /* result */
    goto fail;
  if (!per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
    goto fail;
  if (!per_write_integer16(s, channelId, 0)) /* requested (ChannelId) */
    goto fail;
  if (!per_write_integer16(s, channelId, 0)) /* channelId */
    goto fail;
  Stream_SealLength(s);
  status = transport_write(mcs->transport, s);
fail:
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

/**
 * Receive MCS Disconnect Provider Ultimatum PDU.
 * @param mcs mcs module
 */

BOOL mcs_recv_disconnect_provider_ultimatum(rdpMcs* mcs, wStream* s, int* reason)
{
  BYTE b1 = 0;
  BYTE b2 = 0;

  WINPR_ASSERT(mcs);
  WINPR_ASSERT(s);
  WINPR_ASSERT(reason);

  /*
   * http://msdn.microsoft.com/en-us/library/cc240872.aspx:
   *
   * PER encoded (ALIGNED variant of BASIC-PER) PDU contents:
   * 21 80
   *
   * 0x21:
   * 0 - --\
   * 0 -   |
   * 1 -   | CHOICE: From DomainMCSPDU select disconnectProviderUltimatum (8)
   * 0 -   | of type DisconnectProviderUltimatum
   * 0 -   |
   * 0 - --/
   * 0 - --\
   * 1 -   |
   *       | DisconnectProviderUltimatum::reason = rn-user-requested (3)
   * 0x80: |
   * 1 - --/
   * 0 - padding
   * 0 - padding
   * 0 - padding
   * 0 - padding
   * 0 - padding
   * 0 - padding
   * 0 - padding
   */

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
    return FALSE;

  Stream_Rewind_UINT8(s);
  Stream_Read_UINT8(s, b1);
  Stream_Read_UINT8(s, b2);
  *reason = ((b1 & 0x01) << 1) | (b2 >> 7);
  return TRUE;
}

/**
 * Send MCS Disconnect Provider Ultimatum PDU.
 * @param mcs mcs module
 */

BOOL mcs_send_disconnect_provider_ultimatum(rdpMcs* mcs)
{
  wStream* s = NULL;
  int status = -1;
  UINT16 length = 9;

  WINPR_ASSERT(mcs);

  s = Stream_New(NULL, length);

  if (!s)
    goto fail;

  if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_DisconnectProviderUltimatum, length, 1))
    goto fail;

  if (!per_write_enumerated(s, 0x80, 0))
    goto fail;
  status = transport_write(mcs->transport, s);
fail:
  Stream_Free(s, TRUE);
  return (status < 0) ? FALSE : TRUE;
}

BOOL mcs_client_begin(rdpMcs* mcs)
{
  rdpContext* context = NULL;

  if (!mcs || !mcs->transport)
    return FALSE;

  context = transport_get_context(mcs->transport);

  if (!context)
    return FALSE;

  /* First transition state, we need this to trigger session recording */
  if (!mcs_send_connect_initial(mcs))
  {
    freerdp_set_last_error_if_not(context, FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR);

    WLog_ERR(TAG, "Error: unable to send MCS Connect Initial");
    return FALSE;
  }

  return TRUE;
}

/**
 * Instantiate new MCS module.
 * @param transport transport
 * @return new MCS module
 */

rdpMcs* mcs_new(rdpTransport* transport)
{
  rdpMcs* mcs = NULL;

  mcs = (rdpMcs*)calloc(1, sizeof(rdpMcs));

  if (!mcs)
    return NULL;

  mcs->transport = transport;
  mcs_init_domain_parameters(&mcs->targetParameters, 34, 2, 0, 0xFFFF);
  mcs_init_domain_parameters(&mcs->minimumParameters, 1, 1, 1, 0x420);
  mcs_init_domain_parameters(&mcs->maximumParameters, 0xFFFF, 0xFC17, 0xFFFF, 0xFFFF);
  mcs_init_domain_parameters(&mcs->domainParameters, 0, 0, 0, 0xFFFF);
  mcs->channelCount = 0;
  mcs->channelMaxCount = CHANNEL_MAX_COUNT;
  mcs->baseChannelId = MCS_GLOBAL_CHANNEL_ID + 1;
  mcs->channels = (rdpMcsChannel*)calloc(mcs->channelMaxCount, sizeof(rdpMcsChannel));

  if (!mcs->channels)
    goto out_free;

  return mcs;
out_free:
  free(mcs);
  return NULL;
}

/**
 * Free MCS module.
 * @param mcs MCS module to be freed
 */

void mcs_free(rdpMcs* mcs)
{
  if (mcs)
  {
    free(mcs->channels);
    free(mcs);
  }
}

BOOL mcs_server_apply_to_settings(const rdpMcs* mcs, rdpSettings* settings)
{
  BOOL rc = FALSE;

  WINPR_ASSERT(mcs);
  WINPR_ASSERT(settings);

  if (!freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, mcs->channelCount))
    goto fail;

  for (UINT32 x = 0; x < mcs->channelCount; x++)
  {
    const rdpMcsChannel* current = &mcs->channels[x];
    CHANNEL_DEF def = { 0 };
    def.options = current->options;
    memcpy(def.name, current->Name, sizeof(def.name));
    if (!freerdp_settings_set_pointer_array(settings, FreeRDP_ChannelDefArray, x, &def))
      goto fail;
  }

  rc = TRUE;
fail:
  if (!rc)
    WLog_WARN(TAG, "failed to apply settings");

  return rc;
}

Coverage Report

Created: 2024-09-08 06:20