windows-server-2003/termsrv/newclient/core/mcs.h

/****************************************************************************/
// mcs.h
//
// MCS Class header file
//
// Copyright (C) 1997-1999 Microsoft Corporation
/****************************************************************************/

#ifndef _H_MCS
#define _H_MCS

extern "C" {
    #include <adcgdata.h>
}
#include "objs.h"
#include "cd.h"

#define TRC_FILE    "mcs"
#define TRC_GROUP   TRC_GROUP_NETWORK

//    This constant is the equivalent with the one defined by the mcsimpl.h on 
//    the servers side. The meaning of it is the fact that the input buffers
//    have to be actually bigger with 8 bytes to avoid any overread in the 
//    decompression routines. The decompression function does not strictly 
//    check the input pointers for overread (for performance reasons) so it
//    can overread a maximum of 7 bytes. The bias will make the input buffer
//    8 bytes bigger so the overread can't happen.
#define MCS_INPUT_BUFFER_BIAS 8

/****************************************************************************/
/* MCS result codes.                                                        */
/****************************************************************************/
#define MCS_RESULT_SUCCESSFUL                       0
#define MCS_RESULT_DOMAIN_MERGING                   1
#define MCS_RESULT_DOMAIN_NOT_HIERARCHICAL          2
#define MCS_RESULT_NO_SUCH_CHANNEL                  3
#define MCS_RESULT_NO_SUCH_DOMAIN                   4
#define MCS_RESULT_NO_SUCH_USER                     5
#define MCS_RESULT_NOT_ADMITTED                     6
#define MCS_RESULT_OTHER_USER_ID                    7
#define MCS_RESULT_PARAMETERS_UNACCEPTABLE          8
#define MCS_RESULT_TOKEN_NOT_AVAILABLE              9
#define MCS_RESULT_TOKEN_NOT_POSSESSED              10
#define MCS_RESULT_TOO_MANY_CHANNELS                11
#define MCS_RESULT_TOO_MANY_TOKENS                  12
#define MCS_RESULT_TOO_MANY_USERS                   13
#define MCS_RESULT_UNSPECIFIED_FAILURE              14
#define MCS_RESULT_USER_REJECTED                    15


/****************************************************************************/
/* MCS reason codes.                                                        */
/****************************************************************************/
#define MCS_REASON_DOMAIN_DISCONNECTED              0
#define MCS_REASON_PROVIDER_INITIATED               1
#define MCS_REASON_TOKEN_PURGED                     2
#define MCS_REASON_USER_REQUESTED                   3
#define MCS_REASON_CHANNEL_PURGED                   4


/****************************************************************************/
/* Buffer handle (returned on MCS_GetBuffer).                               */
/****************************************************************************/
typedef ULONG_PTR           MCS_BUFHND;
typedef MCS_BUFHND   DCPTR PMCS_BUFHND;


#define MCS_INVALID_CHANNEL_ID                      0xFFFF


/****************************************************************************/
// MCS_SetDataLengthToReceive
//
// Mcro to allow XT to set up the required length for MCS data buffer
// reception.
/****************************************************************************/
#define MCS_SetDataLengthToReceive(mcsinst, len) \
    (##mcsinst)->_MCS.dataBytesNeeded = (len);  \
    (##mcsinst)->_MCS.dataBytesRead = 0;


/****************************************************************************/
// MCS_RecvToDataBuf
//
// Receives data into the MCS data buffer. Implemented as a macro for speed
// and for easy use within XT for fast-path output receives.  rc is:
//   S_OK if all the data is finished.
//   S_FALSE if there is more data.
//   E_* if an error occurred.
/****************************************************************************/
#define MCS_RecvToDataBuf(rc, xtinst, mcsinst) {  \
    unsigned bytesRecv;  \
\
    /* Make sure that we're expected to receive some data. */  \
    TRC_ASSERT(((mcsinst)->_MCS.dataBytesNeeded != 0), (TB, _T("No data to receive")));  \
    TRC_ASSERT(((mcsinst)->_MCS.dataBytesNeeded < 65535),  \
            (TB,_T("Data recv size %u too large"), (mcsinst)->_MCS.dataBytesNeeded));  \
    TRC_ASSERT(((mcsinst)->_MCS.pReceivedPacket != NULL),  \
            (TB, _T("Null rcv packet buffer")));  \
\
    if (((mcsinst)->_MCS.dataBytesRead + (mcsinst)->_MCS.dataBytesNeeded <= \
            sizeof((mcsinst)->_MCS.dataBuf) - 2 - MCS_INPUT_BUFFER_BIAS)) \
    { \
        /* Get some data into the data buffer. */  \
        bytesRecv = ##xtinst->XT_Recv((mcsinst)->_MCS.pReceivedPacket + (mcsinst)->_MCS.dataBytesRead,  \
                (mcsinst)->_MCS.dataBytesNeeded);  \
        TRC_ASSERT((bytesRecv <= (mcsinst)->_MCS.dataBytesNeeded),  \
                (TB,_T("XT_Recv returned more bytes read (%u) than requested (%u)"),  \
                bytesRecv, (mcsinst)->_MCS.dataBytesNeeded));  \
        (mcsinst)->_MCS.dataBytesNeeded -= bytesRecv;  \
        (mcsinst)->_MCS.dataBytesRead   += bytesRecv;  \
        rc = ((mcsinst)->_MCS.dataBytesNeeded == 0) ? S_OK : S_FALSE; \
    } \
    else \
    { \
        TRC_ABORT((TB, _T("Data buffer size %u too small for %u read + %u needed"),  \
        sizeof((mcsinst)->_MCS.dataBuf) - 2 - MCS_INPUT_BUFFER_BIAS,  \
        (mcsinst)->_MCS.dataBytesRead,  \
        (mcsinst)->_MCS.dataBytesNeeded)); \
        rc = E_ABORT; \
    } \
}



//
// Internal use
//

/****************************************************************************/
/*                                                                          */
/* DEFINITIONS                                                              */
/*                                                                          */
/****************************************************************************/
/****************************************************************************/
/* MCS receive state variables.                                             */
/****************************************************************************/
#define MCS_RCVST_PDUENCODING                   1
#define MCS_RCVST_BERHEADER                     2
#define MCS_RCVST_BERLENGTH                     3
#define MCS_RCVST_CONTROL                       4
#define MCS_RCVST_DATA                          5

/****************************************************************************/
/* MCS receive data state variables.                                        */
/****************************************************************************/
#define MCS_DATAST_SIZE1                        1
#define MCS_DATAST_SIZE2                        2
#define MCS_DATAST_SIZE3                        3
#define MCS_DATAST_READFRAG                     4
#define MCS_DATAST_READREMAINDER                5

/****************************************************************************/
/* Number of bytes required to determine the MCS PDU encoding.              */
/****************************************************************************/
#define MCS_NUM_PDUENCODING_BYTES               1

/****************************************************************************/
/* Size of the common part of an MCS header.                                */
/****************************************************************************/
#define MCS_SIZE_HEADER                         3

/****************************************************************************/
/* The MCS BER connect PDU prefix.                                          */
/****************************************************************************/
#define MCS_BER_CONNECT_PREFIX                  0x7F

/****************************************************************************/
/* Maximum length of the size data in a PER encoded MCS PDU.                */
/****************************************************************************/
#define MCS_MAX_SIZE_DATA_LENGTH                2

/****************************************************************************/
/* Maximum length of a MCS header.                                          */
/****************************************************************************/
#define MCS_DEFAULT_HEADER_LENGTH                   4096

/****************************************************************************/
/* Maximum length of a T.Share packet.                                      */
/****************************************************************************/
#ifdef DC_HICOLOR
#define MCS_MAX_RCVPKT_LENGTH                   (1024*16)
#else
#define MCS_MAX_RCVPKT_LENGTH                   (1024*12)
#endif

/****************************************************************************/
/* Maximum length of a MCS packet to be sent.                               */
/****************************************************************************/
#define MCS_MAX_SNDPKT_LENGTH                   16384

/****************************************************************************/
/* MCS user IDs are encoded as constrained integers in the range            */
/* 1001-65535.  The packed encoding rules (PER) encoded this as an integer  */
/* starting at 0, so we need this constant in decode/encode user-ids.       */
/****************************************************************************/
#define MCS_USERID_PER_OFFSET                   1001

/****************************************************************************/
/* Number of fields in a MCS connect-response PDU.                          */
/****************************************************************************/
#define MCS_CRPDU_NUMFIELDS                     4

/****************************************************************************/
/* Field offsets within a MCS connect-response PDU.                         */
/****************************************************************************/
#define MCS_CRPDU_RESULTOFFSET                  0
#define MCS_CRPDU_USERDATAOFFSET                3

/****************************************************************************/
/* Length of the connect-response result field.                             */
/****************************************************************************/
#define MCS_CR_RESULTLEN                        1

/****************************************************************************/
/* PER encoded field lengths and masks.  The lengths are in bits.           */
/****************************************************************************/
#define MCS_PDUTYPELENGTH                       6
#define MCS_PDUTYPEMASK                         0xFC
#define MCS_RESULTCODELENGTH                    4
#define MCS_RESULTCODEMASK                      0xF
#define MCS_REASONCODELENGTH                    3
#define MCS_REASONCODEMASK                      0x7

/****************************************************************************/
/* Offsets for the following:                                               */
/*                                                                          */
/*  - result and reason codes.                                              */
/*  - optional fields (user-id in AUC and channel-id in CJC).               */
/****************************************************************************/
#define MCS_AUC_RESULTCODEOFFSET                7
#define MCS_AUC_OPTIONALUSERIDLENGTH            1
#define MCS_AUC_OPTIONALUSERIDMASK              0x02
#define MCS_CJC_RESULTCODEOFFSET                7
#define MCS_CJC_OPTIONALCHANNELIDLENGTH         1
#define MCS_CJC_OPTIONALCHANNELIDMASK           0x02
#define MCS_DPUM_REASONCODEOFFSET               6

/****************************************************************************/
/* MCS PDU types.                                                           */
/****************************************************************************/
#define MCS_TYPE_UNKNOWN                        0
#define MCS_TYPE_CONNECTINITIAL                 0x65
#define MCS_TYPE_CONNECTRESPONSE                0x66
#define MCS_TYPE_ATTACHUSERREQUEST              0x28
#define MCS_TYPE_ATTACHUSERCONFIRM              0x2C
#define MCS_TYPE_DETACHUSERREQUEST              0x30
#define MCS_TYPE_DETACHUSERINDICATION           0x34
#define MCS_TYPE_CHANNELJOINREQUEST             0x38
#define MCS_TYPE_CHANNELJOINCONFIRM             0x3C
#define MCS_TYPE_SENDDATAREQUEST                0x64
#define MCS_TYPE_SENDDATAINDICATION             0x68
#define MCS_TYPE_DISCONNECTPROVIDERUM           0x20

/****************************************************************************/
/* Masks used to identify the segmentation flags in a Send-Data-Indication  */
/* PDU.                                                                     */
/****************************************************************************/
#define MCS_SDI_BEGINSEGMASK                    0x20
#define MCS_SDI_ENDSEGMASK                      0x10

/****************************************************************************/
/* MCS hard-coded PDUs - first of all MCS connect initial.                  */
/****************************************************************************/
#define MCS_DATA_CONNECTINITIAL                                              \
                  {0x657F,                 /* PDU type. 7F65 = CI        */  \
                   0x82, 0x00,             /* PDU length (length > 128)  */  \
                   0x04, 0x01, 0x01,       /* Calling domain selector    */  \
                   0x04, 0x01, 0x01,       /* Called domain selector     */  \
                   0x01, 0x01, 0xFF,       /* Upward flag                */  \
                   0x30, 0x19,             /* Target domain params       */  \
                   0x02, 0x01, 0x22,       /*   Max channel IDs          */  \
                   0x02, 0x01, 0x02,       /*   Max user IDs             */  \
                   0x02, 0x01, 0x00,       /*   Max token IDs            */  \
                   0x02, 0x01, 0x01,       /*   Number of priorities     */  \
                   0x02, 0x01, 0x00,       /*   Min throughput           */  \
                   0x02, 0x01, 0x01,       /*   Max height               */  \
                   0x02, 0x02, 0xFF, 0xFF, /*   Max MCSPDU size          */  \
                   0x02, 0x01, 0x02,       /*   Protocol version         */  \
                   0x30, 0x19,             /* Minimum domain parameters  */  \
                   0x02, 0x01, 0x01,       /*   Max channel IDs          */  \
                   0x02, 0x01, 0x01,       /*   Max user IDs             */  \
                   0x02, 0x01, 0x01,       /*   Max token IDs            */  \
                   0x02, 0x01, 0x01,       /*   Number of priorities     */  \
                   0x02, 0x01, 0x00,       /*   Min throughput           */  \
                   0x02, 0x01, 0x01,       /*   Max height               */  \
                   0x02, 0x02, 0x04, 0x20, /*   Max MCSPDU size          */  \
                   0x02, 0x01, 0x02,       /*   Protocol version         */  \
                   0x30, 0x1C,             /* Maximum domain parameters  */  \
                   0x02, 0x02, 0xFF, 0xFF, /*   Max channel IDs          */  \
                   0x02, 0x02, 0xFC, 0x17, /*   Max user IDs             */  \
                   0x02, 0x02, 0xFF, 0xFF, /*   Max token IDs            */  \
                   0x02, 0x01, 0x01,       /*   Number of priorities     */  \
                   0x02, 0x01, 0x00,       /*   Min throughput           */  \
                   0x02, 0x01, 0x01,       /*   Max height               */  \
                   0x02, 0x02, 0xFF, 0xFF, /*   Max MCSPDU size          */  \
                   0x02, 0x01, 0x02,       /*   Protocol version         */  \
                   0x04, 0x82, 0x00}       /* User data                  */  \

/****************************************************************************/
/* Hard-coded data for Erect-Domain-Request PDU.                            */
/****************************************************************************/
#define MCS_DATA_ERECTDOMAINREQUEST                                          \
                  {0x04,                   /* EDrq choice                */  \
                   0x0001,                 /* Sub-height                 */  \
                   0x0001}                 /* Sub-interval               */  \

/****************************************************************************/
/* Hard-coded data for Disconnect-Provider-Ultimatum PDU.  The reason       */
/* is hard-coded to rn-user-requested.                                      */
/****************************************************************************/
#define MCS_DATA_DISCONNECTPROVIDERUM                                        \
                  {0x8021}                 /* DPum choice and reason     */  \

/****************************************************************************/
/* Hard-coded data for Attach-User-Request PDU.                             */
/****************************************************************************/
#define MCS_DATA_ATTACHUSERREQUEST                                           \
                  {0x28}                   /* AUrq choice                */  \

/****************************************************************************/
/* Hard-coded data for Detach-User-Request PDU.                             */
/****************************************************************************/
#define MCS_DATA_DETACHUSERREQUEST                                           \
                  {0x31, 0x80,             /* DUrq choice and reason     */  \
                   0x01,                   /* Set of one user-id         */  \
                   0x0000}                 /* User ID                    */  \

/****************************************************************************/
/* Hard-coded data for Channel-Join-Request PDU.                            */
/****************************************************************************/
#define MCS_DATA_CHANNELJOINREQUEST                                          \
                  {0x38,                   /* CJrq choice                */  \
                   0x0000,                 /* User ID                    */  \
                   0x0000}                 /* Channel ID                 */  \

/****************************************************************************/
/* Hard-coded data for Send-Data-Request PDU.                               */
/****************************************************************************/
#define MCS_DATA_SENDDATAREQUEST                                             \
                  {0x64,                   /* SDrq choice                */  \
                   0x0000,                 /* User ID                    */  \
                   0x0000,                 /* Channel ID                 */  \
                   0x70}                   /* Priority and segmentation  */  \
                   
                   


/****************************************************************************/
/*                                                                          */
/* TYPEDEFS                                                                 */
/*                                                                          */
/****************************************************************************/
/****************************************************************************/
/* Turn on single-byte packing for these structures which we use to         */
/* overlay a byte stream from the network.                                  */
/****************************************************************************/
#pragma pack(push, MCSpack, 1)

/**STRUCT+*******************************************************************/
/* Structure: MCS_BER_1DATABYTE                                             */
/*                                                                          */
/* Description: A BER encoded 1 byte value.                                 */
/****************************************************************************/
typedef struct tagMCS_BER_1DATABYTE
{
    DCUINT8 tag;
    DCUINT8 length;
    DCUINT8 value;

} MCS_BER_1DATABYTE;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_BER_2DATABYTES                                            */
/*                                                                          */
/* Description: A BER encoded 2 byte value.                                 */
/****************************************************************************/
typedef struct tagMCS_BER_2DATABYTES
{
    DCUINT8 tag;
    DCUINT8 length;
    DCUINT8 value[2];

} MCS_BER_2DATABYTES;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_BER_3DATABYTES                                            */
/*                                                                          */
/* Description: A BER encoded 3 byte value.                                 */
/****************************************************************************/
typedef struct tagMCS_BER_3DATABYTES
{
    DCUINT8 tag;
    DCUINT8 length;
    DCUINT8 value[3];

} MCS_BER_3DATABYTES;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_BER_4DATABYTES                                            */
/*                                                                          */
/* Description: A BER encoded 4 byte value.                                 */
/****************************************************************************/
typedef struct tagMCS_BER_4DATABYTES
{
    DCUINT8 tag;
    DCUINT8 length;
    DCUINT8 value[4];

} MCS_BER_4DATABYTES;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_DOMAINPARAMETERS                                          */
/*                                                                          */
/* Description: Represents a Domain-Parameters sequence.                    */
/****************************************************************************/
typedef struct tagMCS_DOMAINPARAMETERS
{
    DCUINT8            tag;
    DCUINT8            length;
    MCS_BER_2DATABYTES maxChanIDs;
    MCS_BER_2DATABYTES maxUserIDs;
    MCS_BER_2DATABYTES maxTokenIDs;
    MCS_BER_1DATABYTE  numPriorities;
    MCS_BER_1DATABYTE  minThroughPut;
    MCS_BER_1DATABYTE  maxHeight;
    MCS_BER_2DATABYTES maxMCSPDUSize;
    MCS_BER_1DATABYTE  protocolVersion;

} MCS_DOMAINPARAMETERS;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_TARGETDOMAINPARAMETERS                                    */
/*                                                                          */
/* Description: Represents a Domain-Parameters sequence.                    */
/****************************************************************************/
typedef struct tagMCS_TARGETDOMAINPARAMETERS
{
    DCUINT8            tag;
    DCUINT8            length;
    MCS_BER_1DATABYTE  maxChanIDs;
    MCS_BER_1DATABYTE  maxUserIDs;
    MCS_BER_1DATABYTE  maxTokenIDs;
    MCS_BER_1DATABYTE  numPriorities;
    MCS_BER_1DATABYTE  minThroughPut;
    MCS_BER_1DATABYTE  maxHeight;
    MCS_BER_2DATABYTES maxMCSPDUSize;
    MCS_BER_1DATABYTE  protocolVersion;

} MCS_TARGETDOMAINPARAMETERS;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_MINDOMAINPARAMETERS                                       */
/*                                                                          */
/* Description: Represents a Domain-Parameters sequence.                    */
/****************************************************************************/
typedef struct tagMCS_MINDOMAINPARAMETERS
{
    DCUINT8            tag;
    DCUINT8            length;
    MCS_BER_1DATABYTE  maxChanIDs;
    MCS_BER_1DATABYTE  maxUserIDs;
    MCS_BER_1DATABYTE  maxTokenIDs;
    MCS_BER_1DATABYTE  numPriorities;
    MCS_BER_1DATABYTE  minThroughPut;
    MCS_BER_1DATABYTE  maxHeight;
    MCS_BER_2DATABYTES maxMCSPDUSize;
    MCS_BER_1DATABYTE  protocolVersion;

} MCS_MINDOMAINPARAMETERS;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_MAXDOMAINPARAMETERS                                       */
/*                                                                          */
/* Description: Represents a Domain-Parameters sequence.                    */
/****************************************************************************/
typedef struct tagMCS_MAXDOMAINPARAMETERS
{
    DCUINT8            tag;
    DCUINT8            length;
    MCS_BER_2DATABYTES maxChanIDs;
    MCS_BER_2DATABYTES maxUserIDs;
    MCS_BER_2DATABYTES maxTokenIDs;
    MCS_BER_1DATABYTE  numPriorities;
    MCS_BER_1DATABYTE  minThroughPut;
    MCS_BER_1DATABYTE  maxHeight;
    MCS_BER_2DATABYTES maxMCSPDUSize;
    MCS_BER_1DATABYTE  protocolVersion;

} MCS_MAXDOMAINPARAMETERS;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_CONNECTINITIAL                                        */
/*                                                                          */
/* Description: Represents a Connect-Initial PDU.                           */
/****************************************************************************/
typedef struct tagMCS_PDU_CONNECTINITIAL
{
    DCUINT16                   type;
    DCUINT8                    lengthLength;
    DCUINT16                   length;
    MCS_BER_1DATABYTE          callingDS;
    MCS_BER_1DATABYTE          calledDS;
    MCS_BER_1DATABYTE          upwardFlag;
    MCS_TARGETDOMAINPARAMETERS targetParams;
    MCS_MINDOMAINPARAMETERS    minimumParams;
    MCS_MAXDOMAINPARAMETERS    maximumParams;
    DCUINT8                    udIdentifier;
    DCUINT8                    udLengthLength;
    DCUINT16                   udLength;

} MCS_PDU_CONNECTINITIAL, DCPTR PMCS_PDU_CONNECTINITIAL;
/**STRUCT-*******************************************************************/


/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_CONNECTRESPONSE                                       */
/*                                                                          */
/* Description: Represents a Connect-Response PDU.                          */
/****************************************************************************/
typedef struct tagMCS_PDU_CONNECTRESPONSE
{
    DCUINT16             type;
    DCUINT8              length;
    MCS_BER_1DATABYTE    result;
    MCS_BER_1DATABYTE    connectID;
    MCS_DOMAINPARAMETERS domainParams;
    DCUINT8              userDataType;
    DCUINT8              userDataLength;

} MCS_PDU_CONNECTRESPONSE, DCPTR PMCS_PDU_CONNECTRESPONSE;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_ERECTDOMAINREQUEST                                    */
/*                                                                          */
/* Description: Represents a Erect-Domain-Request PDU.                      */
/****************************************************************************/
typedef struct tagMCS_PDU_ERECTDOMAINREQUEST
{
    DCUINT8  type;
    DCUINT16 subHeight;
    DCUINT16 subInterval;

} MCS_PDU_ERECTDOMAINREQUEST, DCPTR PMCS_PDU_ERECTDOMAINREQUEST;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_DISCONNECTPROVIDERUM                                  */
/*                                                                          */
/* Description: Represents a Disconnect-Provider-Ultimatum PDU              */
/****************************************************************************/
typedef struct tagMCS_PDU_DISCONNECTPROVIDERUM
{
    DCUINT16 typeReason;

} MCS_PDU_DISCONNECTPROVIDERUM, DCPTR PMCS_PDU_DISCONNECTPROVIDERUM;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_ATTACHUSERREQUEST                                     */
/*                                                                          */
/* Description: Represents an Attach-User-Request PDU.                      */
/****************************************************************************/
typedef struct tagMCS_PDU_ATTACHUSERREQUEST
{
    DCUINT8 type;

} MCS_PDU_ATTACHUSERREQUEST, DCPTR PMCS_PDU_ATTACHUSERREQUEST;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_ATTACHUSERCONFIRMCOMMON                               */
/*                                                                          */
/* Description: Represents the always present part of a Attach-User-Confirm */
/*              PDU.                                                        */
/****************************************************************************/
typedef struct tagMCS_PDU_ATTACHUSERCONFIRMCOMMON
{
    DCUINT16 typeResult;

} MCS_PDU_ATTACHUSERCONFIRMCOMMON, DCPTR PMCS_PDU_ATTACHUSERCONFIRMCOMMON;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_ATTACHUSERCONFIRMFULL                                 */
/*                                                                          */
/* Description: Represents a full Attach-User-Confirm PDU with the optional */
/*              userID.                                                     */
/****************************************************************************/
typedef struct tagMCS_PDU_ATTACHUSERCONFIRMFULL
{
    MCS_PDU_ATTACHUSERCONFIRMCOMMON common;
    DCUINT16                        userID;

} MCS_PDU_ATTACHUSERCONFIRMFULL, DCPTR PMCS_PDU_ATTACHUSERCONFIRMFULL;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_DETACHUSERREQUEST                                     */
/*                                                                          */
/* Description: Represents a Detach-User-Request PDU.                       */
/****************************************************************************/
typedef struct tagMCS_PDU_DETACHUSERREQUEST
{
    DCUINT8  type;
    DCUINT8  reason;
    DCUINT8  set;
    DCUINT16 userID;

} MCS_PDU_DETACHUSERREQUEST, DCPTR PMCS_PDU_DETACHUSERREQUEST;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_DETACHUSERINDICATION                                  */
/*                                                                          */
/* Description: Represents a Detach-User-Indication PDU.                    */
/****************************************************************************/
typedef struct tagMCS_PDU_DETACHUSERINDICATION
{
    DCUINT8  type;
    DCUINT8  reason;
    DCUINT8  set;
    DCUINT16 userID;

} MCS_PDU_DETACHUSERINDICATION, DCPTR PMCS_PDU_DETACHUSERINDICATION;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_CHANNELJOINREQUEST                                    */
/*                                                                          */
/* Description: Represents a Channel-Join-Request PDU.                      */
/****************************************************************************/
typedef struct tagMCS_PDU_CHANNELJOINREQUEST
{
    DCUINT8  type;
    DCUINT16 initiator;
    DCUINT16 channelID;

} MCS_PDU_CHANNELJOINREQUEST, DCPTR PMCS_PDU_CHANNELJOINREQUEST;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_CHANNELJOINCONFIRMCOMMON                              */
/*                                                                          */
/* Description: Represents the always present part of a                     */
/*              Channel-Join-Confirm PDU.                                   */
/****************************************************************************/
typedef struct tagMCS_PDU_CHANNELJOINCONFIRMCOMMON
{
    DCUINT16 typeResult;
    DCUINT16 initiator;
    DCUINT16 requested;

} MCS_PDU_CHANNELJOINCONFIRMCOMMON, DCPTR PMCS_PDU_CHANNELJOINCONFIRMCOMMON;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_CHANNELJOINCONFIRMFULL                                */
/*                                                                          */
/* Description: Represents a full Channel-Join-Confirm PDU including the    */
/*              optional channel-ID.                                        */
/****************************************************************************/
typedef struct tagMCS_PDU_CHANNELJOINCONFIRM
{
    MCS_PDU_CHANNELJOINCONFIRMCOMMON common;
    DCUINT16                         channelID;

} MCS_PDU_CHANNELJOINCONFIRMFULL, DCPTR PMCS_PDU_CHANNELJOINCONFIRMFULL;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_SENDDATAINDICATION                                    */
/*                                                                          */
/* Description: Represents a Send-Data-Indication PDU.                      */
/****************************************************************************/
typedef struct tagMCS_PDU_SENDDATAINDICATION
{
    DCUINT8  type;
    DCUINT16 userID;
    DCUINT16 channelID;
    DCUINT8  priSeg;

} MCS_PDU_SENDDATAINDICATION, DCPTR PMCS_PDU_SENDDATAINDICATION;
/**STRUCT-*******************************************************************/

/**STRUCT+*******************************************************************/
/* Structure: MCS_PDU_SENDDATAREQUEST                                       */
/*                                                                          */
/* Description: Represents a Send-Data-Request PDU.                         */
/****************************************************************************/
typedef struct tagMCS_PDU_SENDDATAREQUEST
{
    DCUINT8  type;
    DCUINT16 userID;
    DCUINT16 channelID;
    DCUINT8  priSeg;

} MCS_PDU_SENDDATAREQUEST;
/**STRUCT-*******************************************************************/

/****************************************************************************/
/* Reset structure packing to its default.                                  */
/****************************************************************************/
#pragma pack(pop, MCSpack)

/**STRUCT+*******************************************************************/
/* Structure: MCS_DECOUPLEINFO                                              */
/*                                                                          */
/* Description: Structure used when decoupling channel and userIDs.         */
/****************************************************************************/
typedef struct tagMCS_DECOUPLEINFO
{
    DCUINT channel;
    DCUINT userID;

} MCS_DECOUPLEINFO, DCPTR PMCS_DECOUPLEINFO;
/**STRUCT-*******************************************************************/





/****************************************************************************/
/*                                                                          */
/* TYPEDEFS                                                                 */
/*                                                                          */
/****************************************************************************/
/**STRUCT+*******************************************************************/
/* Structure: MCS_GLOBAL_DATA                                               */
/*                                                                          */
/* Description: The MCS global data.                                        */
/****************************************************************************/
typedef struct tagMCS_GLOBAL_DATA
{
    DCUINT   rcvState;
    DCUINT   hdrBytesNeeded;
    DCUINT   hdrBytesRead;
    DCUINT   dataState;
    DCUINT   dataBytesNeeded;
    DCUINT   dataBytesRead;
    DCUINT   userDataLength;
    DCUINT   disconnectReason;
    PDCUINT8 pReceivedPacket;
    DCUINT8  pSizeBuf[MCS_MAX_SIZE_DATA_LENGTH];
    PDCUINT8 pHdrBuf;
    DCUINT   hdrBufLen;

    //
    // Channel with a pending join request - use this
    // to validate that the server isn't sending us bogus
    // joins for channels we didn't request
    //
    DCUINT16    pendingChannelJoin;
    DCUINT16    pad;
                             /* Note: dataBuf must start on 4-byte boundary */
    //    The decompression function does not check strictly the input buffer
    //    for performance reasons. So it can overread up to 8 bytes. So we pad
    //    the input buffer with enough bytes to avoid the overread.
    DCUINT8  dataBuf[MCS_MAX_RCVPKT_LENGTH + 2 + MCS_INPUT_BUFFER_BIAS];

} MCS_GLOBAL_DATA;
/**STRUCT-*******************************************************************/




//
// Class definition
//



class CCD;
class CNC;
class CUT;
class CXT;
class CNL;
class CSL;


class CMCS
{
public:

    CMCS(CObjs* objs);
    ~CMCS();

public:
    //
    // API functions
    //

    /****************************************************************************/
    /* FUNCTIONS                                                                */
    /****************************************************************************/
    DCVOID DCAPI MCS_Init(DCVOID);
    
    DCVOID DCAPI MCS_Term(DCVOID);
    
    DCVOID DCAPI MCS_Connect(BOOL     bInitateConnect,
                             PDCTCHAR pServerAddress,
                             PDCUINT8 pUserData,
                             DCUINT   userDataLength);

    DCVOID DCAPI MCS_Disconnect(DCVOID);
    
    DCVOID DCAPI MCS_AttachUser(DCVOID);
    
    DCVOID DCAPI MCS_JoinChannel(DCUINT channel, DCUINT userID);
    
    DCBOOL DCAPI MCS_GetBuffer(DCUINT      dataLen,
                               PPDCUINT8   ppBuffer,
                               PMCS_BUFHND pBufHandle);
    
    DCVOID DCAPI MCS_SendPacket(PDCUINT8   pData,
                                DCUINT     dataLen,
                                DCUINT     flags,
                                MCS_BUFHND bufHandle,
                                DCUINT     userID,
                                DCUINT     channel,
                                DCUINT     priority);
    
    DCVOID DCAPI MCS_FreeBuffer(MCS_BUFHND bufHandle);
    
public:
    //
    // Callbacks
    //

    DCVOID DCCALLBACK MCS_OnXTConnected(DCVOID);
    
    DCVOID DCCALLBACK MCS_OnXTDisconnected(DCUINT reason);
    
    DCBOOL DCCALLBACK MCS_OnXTDataAvailable(DCVOID);
    
    DCVOID DCCALLBACK MCS_OnXTBufferAvailable(DCVOID);

    //
    // Static versions
    //

    DCVOID DCCALLBACK MCS_StaticOnXTConnected(CMCS* inst)
    {
        inst->MCS_OnXTConnected();
    }
    
    DCVOID DCCALLBACK MCS_StaticOnXTDisconnected(CMCS* inst, DCUINT reason)
    {
        inst->MCS_OnXTDisconnected(reason);
    }
    
    DCBOOL DCCALLBACK MCS_StaticOnXTDataAvailable(CMCS* inst)
    {
        return inst->MCS_OnXTDataAvailable();
    }
    
    DCVOID DCCALLBACK MCS_StaticOnXTBufferAvailable(CMCS* inst)
    {
        inst->MCS_OnXTBufferAvailable();
    }

    DCUINT16 MCS_GetPendingChannelJoin()
    {
        return _MCS.pendingChannelJoin;
    }

    VOID MCS_SetPendingChannelJoin(DCUINT16 pendingChannelJoin)
    {
        _MCS.pendingChannelJoin = pendingChannelJoin;
    }



    DCVOID DCINTERNAL MCSSendConnectInitial(ULONG_PTR event);
    EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CMCS, MCSSendConnectInitial);

    DCVOID DCINTERNAL MCSSendErectDomainRequest(ULONG_PTR event);
    EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CMCS, MCSSendErectDomainRequest);
    
    DCVOID DCINTERNAL MCSSendAttachUserRequest(ULONG_PTR unused);
    EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CMCS, MCSSendAttachUserRequest);
    
    DCVOID DCINTERNAL MCSSendChannelJoinRequest(PDCVOID pData, DCUINT dataLen);
    EXPOSE_CD_NOTIFICATION_FN(CMCS, MCSSendChannelJoinRequest);

    DCVOID DCINTERNAL MCSSendDisconnectProviderUltimatum(ULONG_PTR unused);
    EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CMCS, MCSSendDisconnectProviderUltimatum);
    
    DCVOID DCINTERNAL MCSContinueDisconnect(ULONG_PTR unused);
    EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CMCS, MCSContinueDisconnect);


public:
    //
    // Public data members
    //

    MCS_GLOBAL_DATA _MCS;


private:

    //
    // Internal functions
    //

    /****************************************************************************/
    /* Inline functions to convert between MCS byte order and local byte order. */
    /****************************************************************************/
    DCUINT16 DCINTERNAL MCSWireToLocal16(DCUINT16 val)
    {
        return((DCUINT16) (((DCUINT16)(((PDCUINT8)&(val))[0]) << 8) | \
                                        ((DCUINT16)(((PDCUINT8)&(val))[1]))));
    }
    #define MCSLocalToWire16 MCSWireToLocal16
    
    /****************************************************************************/
    /* Inline function to extract the result code from a PER encoded PDU.       */
    /* Typically the bits in the first two bytes are used as follows (the       */
    /* following is for an Attach-User-Confirm PDU).                            */
    /*                                                                          */
    /*       BYTE1            BYTE2                                             */
    /*  MSB         LSB  MSB         LSB                                        */
    /*  T T T T T T O R  R R R P P P P P                                        */
    /*                                                                          */
    /*  T: 6 bits used to identify the PDU type.                                */
    /*  O: 1 bit indicating whether the optional field is present.              */
    /*  R: 4 bits used for the result code.                                     */
    /*  P: 5 bits of padding.                                                   */
    /*                                                                          */
    /* Note: the optional bit "O" may or may not be present depending on the    */
    /*       PDU.                                                               */
    /*                                                                          */
    /* Parameters:  IN  value  - the value from which to extract the reason     */
    /*                           code in wire format.                           */
    /*              IN  offset - the offset from the MSB to the first bit of    */
    /*                           the result code.                               */
    /****************************************************************************/
    DCUINT DCINTERNAL MCSGetResult(DCUINT16 value, DCUINT offset)
    {
        DCUINT16 machineValue;
        DCUINT   shiftValue;
        DCUINT   result;
    
        DC_BEGIN_FN("MCSGetResult");
    
        /************************************************************************/
        /* Convert the value from wire to local machine format.                 */
        /************************************************************************/
        machineValue = MCSWireToLocal16(value);
    
        /************************************************************************/
        /* Now shift it right by the appropriate amount.  This amount is 16     */
        /* bits minus (the offset plus the length of the result code).          */
        /************************************************************************/
        shiftValue = 16 - (offset + MCS_RESULTCODELENGTH);
        machineValue >>= shiftValue;
    
        /************************************************************************/
        /* Finally mask off the bottom byte which contains the result code.     */
        /************************************************************************/
        result = machineValue & MCS_RESULTCODEMASK;
    
        TRC_NRM((TB, _T("Shift %#hx right by %u to get %#hx.  Mask to get %#x"),
                 MCSWireToLocal16(value),
                 shiftValue,
                 machineValue,
                 result));
    
        DC_END_FN();
        return(result);
    }
    
    /****************************************************************************/
    /* Macro to extract the reason code from a PER encoded PDU.  Typically      */
    /* the bits in the first two bytes are used as follows (the following is    */
    /* for a Disconnect-Provider-Ultimatum).                                    */
    /*                                                                          */
    /*       BYTE1            BYTE2                                             */
    /*  MSB         LSB  MSB         LSB                                        */
    /*  T T T T T T R R  R P P P P P P P                                        */
    /*                                                                          */
    /*  T: 6 bits used to identify the PDU type.                                */
    /*  R: 3 bits used for the result code.                                     */
    /*  P: 7 bits of padding.                                                   */
    /*                                                                          */
    /* Parameters:  IN  value  - the value from which to extract the reason     */
    /*                           code in wire format.                           */
    /*              IN  offset - the offset from the MSB to the first bit of    */
    /*                           the reason code.                               */
    /****************************************************************************/
    DCUINT DCINTERNAL MCSGetReason(DCUINT16 value, DCUINT offset)
    {
        DCUINT16 machineValue;
        DCUINT   shiftValue;
        DCUINT   reason;
    
        DC_BEGIN_FN("MCSGetResult");
    
        /************************************************************************/
        /* Convert the value from wire to local machine format.                 */
        /************************************************************************/
        machineValue = MCSWireToLocal16(value);
    
        /************************************************************************/
        /* Now shift it right by the appropriate amount.  This amount is 16     */
        /* bits minus (the offset plus the length of the reason code).          */
        /************************************************************************/
        shiftValue = 16 - (offset + MCS_REASONCODELENGTH);
        machineValue >>= shiftValue;
    
        /************************************************************************/
        /* Finally mask off the bottom byte which contains the reason code.     */
        /************************************************************************/
        reason = machineValue & MCS_REASONCODEMASK;
    
        TRC_NRM((TB, _T("Shift %#hx right by %u to get %#hx.  Mask to get %#x"),
                 MCSWireToLocal16(value),
                 shiftValue,
                 machineValue,
                 reason));
    
        DC_END_FN();
        return(reason);
    }
    
    /****************************************************************************/
    /* Inline functions to convert user-ids between the PER encoded values and  */
    /* the wire format.                                                         */
    /****************************************************************************/
    DCUINT16 DCINTERNAL MCSWireUserIDToLocalUserID(DCUINT16 wireUserID)
    {
        /************************************************************************/
        /* Convert from wire to local byte order and then add the PER encoding  */
        /* offset.                                                              */
        /************************************************************************/
        return((DCUINT16)(MCSWireToLocal16(wireUserID) + MCS_USERID_PER_OFFSET));
    }
    
    DCUINT16 DCINTERNAL MCSLocalUserIDToWireUserID(DCUINT16 localUserID)
    {
        /************************************************************************/
        /* Subtract the PER encoding offset and then convert from local to wire */
        /* byte order.                                                          */
        /************************************************************************/
        return(MCSLocalToWire16((DCUINT16)(localUserID - MCS_USERID_PER_OFFSET)));
    }
    
    /****************************************************************************/
    /* Inline function to calculate the number of length bytes in a BER         */
    /* encoded length.                                                          */
    /****************************************************************************/
    DCUINT DCINTERNAL MCSGetBERLengthSize(DCUINT8 firstByte)
    {
        DCUINT numLenBytes;
    
        DC_BEGIN_FN("MCSGetBERLengthSize");
    
        /************************************************************************/
        /* Check if the top bit is set.                                         */
        /************************************************************************/
        if (0x80 & firstByte)
        {
            /********************************************************************/
            /* The top bit is set - the low seven bits contain the number of    */
            /* length bytes.                                                    */
            /********************************************************************/
            numLenBytes = (firstByte & 0x7F) + 1;
            TRC_NRM((TB, _T("Top bit set - numLenBytes:%u"), numLenBytes));
        }
        else
        {
            /********************************************************************/
            /* The top bit was not set - this field contains the length.        */
            /********************************************************************/
            numLenBytes = 1;
            TRC_NRM((TB, _T("Top bit NOT set - numLenBytes:%u firstByte:%u"),
                     numLenBytes,
                     firstByte));
        }
    
        DC_END_FN();
        return(numLenBytes);
    }
    
    /****************************************************************************/
    /* Inline function to calculate the length of a BER encoded field.          */
    /****************************************************************************/
    DCUINT DCINTERNAL MCSGetBERLength(PDCUINT8 pLength)
    {
        DCUINT length = 0;
        DCUINT numLenBytes;
    
        DC_BEGIN_FN("MCSGetBERLength");
    
        TRC_ASSERT((pLength != NULL), (TB, _T("pLength is NULL")));
    
        /************************************************************************/
        /* Calculate the number of length bytes.                                */
        /************************************************************************/
        numLenBytes = MCSGetBERLengthSize(*pLength);
    
        switch (numLenBytes)
        {
            case 1:
            {
                /****************************************************************/
                /* The length is less than 128 bytes so the first field         */
                /* contains the length.                                         */
                /****************************************************************/
                length = *pLength;
            }
            break;
    
            case 2:
            {
                /****************************************************************/
                /* The length is >= 128 bytes but less than 256 bytes so it     */
                /* is encoded in the second byte.                               */
                /****************************************************************/
                pLength++;
                length = *pLength;
            }
            break;
    
            case 3:
            {
                /****************************************************************/
                /* The length is >= 256 bytes and less than 65535 bytes so it   */
                /* is encoded in bytes two and three.                           */
                /****************************************************************/
                pLength++;
                length = (DCUINT16)*pLength;
                pLength++;
                length = (length << 8) + (DCUINT16)*pLength;
            }
            break;
    
            default:
            {
                TRC_ABORT((TB, _T("Too many length bytes:%u"), numLenBytes));
            }
            break;
        }
    
        TRC_NRM((TB, _T("numLenBytes:%u length:%u"), numLenBytes, length));
    
        DC_END_FN();
        return(length);
    }
    
    
    /****************************************************************************/
    /*                                                                          */
    /* FUNCTIONS                                                                */
    /*                                                                          */
    /****************************************************************************/
    
    DCUINT DCINTERNAL MCSGetSDRHeaderLength(DCUINT dataLength);
    
    DCBOOL DCINTERNAL MCSRecvToHdrBuf(DCVOID);
    
    DCBOOL DCINTERNAL MCSRecvToDataBuf(DCVOID);
    
    DCVOID DCINTERNAL MCSGetPERInfo(PDCUINT pType, PDCUINT pSize);
    
    DCVOID DCINTERNAL MCSHandleControlPkt(DCVOID);
    
    DCVOID DCINTERNAL MCSHandleCRPDU(DCVOID);
    
    HRESULT DCINTERNAL MCSRecvData(BOOL *pfFinishedData);
    
    DCVOID DCINTERNAL MCSSetReasonAndDisconnect(DCUINT reason);

private:
    CCD* _pCd;
    CNC* _pNc;
    CUT* _pUt;
    CXT* _pXt;
    CNL* _pNl;
    CSL* _pSl;

private:
    CObjs* _pClientObjects;

};

#undef TRC_FILE
#undef TRC_GROUP

#endif // _H_MCS