754 lines
23 KiB
Go
754 lines
23 KiB
Go
package t125
|
||
|
||
import (
|
||
"bytes"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log/slog"
|
||
"reflect"
|
||
"time"
|
||
|
||
// "git.zeroonesoft.cn/golib/rdplib/plugin/cliprdr"
|
||
"git.zeroonesoft.cn/golib/rdplib/plugin/drdynvc"
|
||
"git.zeroonesoft.cn/golib/rdplib/plugin/rail"
|
||
"git.zeroonesoft.cn/golib/rdplib/plugin/rdpsnd"
|
||
|
||
"git.zeroonesoft.cn/golib/rdplib/core"
|
||
"git.zeroonesoft.cn/golib/rdplib/emission"
|
||
"git.zeroonesoft.cn/golib/rdplib/protocol/t125/ber"
|
||
"git.zeroonesoft.cn/golib/rdplib/protocol/t125/gcc"
|
||
"git.zeroonesoft.cn/golib/rdplib/protocol/t125/per"
|
||
)
|
||
|
||
// take idea from https://github.com/Madnikulin50/gordp
|
||
|
||
// Multiple Channel Service layer
|
||
|
||
type MCSMessage uint8
|
||
|
||
const (
|
||
MCS_TYPE_CONNECT_INITIAL MCSMessage = 0x65
|
||
MCS_TYPE_CONNECT_RESPONSE = 0x66
|
||
)
|
||
|
||
type MCSDomainPDU uint16
|
||
|
||
const (
|
||
ERECT_DOMAIN_REQUEST MCSDomainPDU = 1
|
||
DISCONNECT_PROVIDER_ULTIMATUM = 8
|
||
ATTACH_USER_REQUEST = 10
|
||
ATTACH_USER_CONFIRM = 11
|
||
CHANNEL_JOIN_REQUEST = 14
|
||
CHANNEL_JOIN_CONFIRM = 15
|
||
SEND_DATA_REQUEST = 25
|
||
SEND_DATA_INDICATION = 26
|
||
)
|
||
|
||
const (
|
||
MCS_GLOBAL_CHANNEL_ID uint16 = 1003
|
||
MCS_USERCHANNEL_BASE = 1001
|
||
)
|
||
|
||
const (
|
||
GLOBAL_CHANNEL_NAME = "global"
|
||
)
|
||
|
||
/**
|
||
* Format MCS PDULayer header packet
|
||
* @param mcsPdu {integer}
|
||
* @param options {integer}
|
||
* @returns {type.UInt8} headers
|
||
*/
|
||
func writeMCSPDUHeader(mcsPdu MCSDomainPDU, options uint8, w io.Writer) {
|
||
core.WriteUInt8((uint8(mcsPdu)<<2)|options, w)
|
||
}
|
||
|
||
func readMCSPDUHeader(options uint8, mcsPdu MCSDomainPDU) bool {
|
||
return (options >> 2) == uint8(mcsPdu)
|
||
}
|
||
|
||
type DomainParameters struct {
|
||
MaxChannelIds int
|
||
MaxUserIds int
|
||
MaxTokenIds int
|
||
NumPriorities int
|
||
MinThoughput int
|
||
MaxHeight int
|
||
MaxMCSPDUsize int
|
||
ProtocolVersion int
|
||
}
|
||
|
||
/**
|
||
* @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25
|
||
* @returns {asn1.univ.Sequence}
|
||
*/
|
||
func NewDomainParameters(
|
||
maxChannelIds int,
|
||
maxUserIds int,
|
||
maxTokenIds int,
|
||
numPriorities int,
|
||
minThoughput int,
|
||
maxHeight int,
|
||
maxMCSPDUsize int,
|
||
protocolVersion int) *DomainParameters {
|
||
return &DomainParameters{maxChannelIds, maxUserIds, maxTokenIds,
|
||
numPriorities, minThoughput, maxHeight, maxMCSPDUsize, protocolVersion}
|
||
}
|
||
|
||
func (d *DomainParameters) BER() []byte {
|
||
buff := &bytes.Buffer{}
|
||
ber.WriteInteger(d.MaxChannelIds, buff)
|
||
ber.WriteInteger(d.MaxUserIds, buff)
|
||
ber.WriteInteger(d.MaxTokenIds, buff)
|
||
ber.WriteInteger(1, buff)
|
||
ber.WriteInteger(0, buff)
|
||
ber.WriteInteger(1, buff)
|
||
ber.WriteInteger(d.MaxMCSPDUsize, buff)
|
||
ber.WriteInteger(2, buff)
|
||
return buff.Bytes()
|
||
}
|
||
|
||
func ReadDomainParameters(r io.Reader) (*DomainParameters, error) {
|
||
if !ber.ReadUniversalTag(ber.TAG_SEQUENCE, true, r) {
|
||
return nil, errors.New("bad BER tags")
|
||
}
|
||
d := &DomainParameters{}
|
||
ber.ReadLength(r)
|
||
|
||
d.MaxChannelIds, _ = ber.ReadInteger(r)
|
||
d.MaxUserIds, _ = ber.ReadInteger(r)
|
||
d.MaxTokenIds, _ = ber.ReadInteger(r)
|
||
ber.ReadInteger(r)
|
||
ber.ReadInteger(r)
|
||
ber.ReadInteger(r)
|
||
d.MaxMCSPDUsize, _ = ber.ReadInteger(r)
|
||
ber.ReadInteger(r)
|
||
return d, nil
|
||
}
|
||
|
||
/**
|
||
* @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25
|
||
* @param userData {Buffer}
|
||
* @returns {asn1.univ.Sequence}
|
||
*/
|
||
type ConnectInitial struct {
|
||
CallingDomainSelector []byte
|
||
CalledDomainSelector []byte
|
||
UpwardFlag bool
|
||
TargetParameters DomainParameters
|
||
MinimumParameters DomainParameters
|
||
MaximumParameters DomainParameters
|
||
UserData []byte
|
||
}
|
||
|
||
func NewConnectInitial(userData []byte) ConnectInitial {
|
||
return ConnectInitial{[]byte{0x1},
|
||
[]byte{0x1},
|
||
true,
|
||
*NewDomainParameters(34, 2, 0, 1, 0, 1, 0xffff, 2),
|
||
*NewDomainParameters(1, 1, 1, 1, 0, 1, 0x420, 2),
|
||
*NewDomainParameters(0xffff, 0xfc17, 0xffff, 1, 0, 1, 0xffff, 2),
|
||
userData}
|
||
}
|
||
|
||
func (c *ConnectInitial) BER() []byte {
|
||
buff := &bytes.Buffer{}
|
||
ber.WriteOctetstring(string(c.CallingDomainSelector), buff)
|
||
ber.WriteOctetstring(string(c.CalledDomainSelector), buff)
|
||
ber.WriteBoolean(c.UpwardFlag, buff)
|
||
ber.WriteEncodedDomainParams(c.TargetParameters.BER(), buff)
|
||
ber.WriteEncodedDomainParams(c.MinimumParameters.BER(), buff)
|
||
ber.WriteEncodedDomainParams(c.MaximumParameters.BER(), buff)
|
||
ber.WriteOctetstring(string(c.UserData), buff)
|
||
return buff.Bytes()
|
||
}
|
||
|
||
/**
|
||
* @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25
|
||
* @returns {asn1.univ.Sequence}
|
||
*/
|
||
|
||
type ConnectResponse struct {
|
||
result uint8
|
||
calledConnectId int
|
||
domainParameters *DomainParameters
|
||
userData []byte
|
||
}
|
||
|
||
func NewConnectResponse(userData []byte) *ConnectResponse {
|
||
return &ConnectResponse{0,
|
||
0,
|
||
NewDomainParameters(22, 3, 0, 1, 0, 1, 0xfff8, 2),
|
||
userData}
|
||
}
|
||
|
||
func ReadConnectResponse(r io.Reader) (*ConnectResponse, error) {
|
||
c := &ConnectResponse{}
|
||
var err error
|
||
_, err = ber.ReadApplicationTag(MCS_TYPE_CONNECT_RESPONSE, r)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
c.result, err = ber.ReadEnumerated(r)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
c.calledConnectId, err = ber.ReadInteger(r)
|
||
c.domainParameters, err = ReadDomainParameters(r)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !ber.ReadUniversalTag(ber.TAG_OCTET_STRING, false, r) {
|
||
return nil, errors.New("invalid expected BER tag")
|
||
}
|
||
dataLen, _ := ber.ReadLength(r)
|
||
c.userData, err = core.ReadBytes(dataLen, r)
|
||
return c, err
|
||
}
|
||
|
||
type MCSChannelInfo struct {
|
||
ID uint16
|
||
Name string
|
||
}
|
||
|
||
type MCS struct {
|
||
emission.Emitter
|
||
transport core.Transport
|
||
recvOpCode MCSDomainPDU
|
||
sendOpCode MCSDomainPDU
|
||
channels []MCSChannelInfo
|
||
}
|
||
|
||
func NewMCS(t core.Transport, recvOpCode MCSDomainPDU, sendOpCode MCSDomainPDU) *MCS {
|
||
m := &MCS{
|
||
*emission.NewEmitter(),
|
||
t,
|
||
recvOpCode,
|
||
sendOpCode,
|
||
[]MCSChannelInfo{{MCS_GLOBAL_CHANNEL_ID, GLOBAL_CHANNEL_NAME}},
|
||
}
|
||
|
||
m.transport.On("close", func() {
|
||
m.Emit("close")
|
||
}).On("error", func(err error) {
|
||
m.Emit("error", err)
|
||
})
|
||
return m
|
||
}
|
||
|
||
func (x *MCS) Read(b []byte) (n int, err error) {
|
||
return x.transport.Read(b)
|
||
}
|
||
|
||
func (x *MCS) Write(b []byte) (n int, err error) {
|
||
return x.transport.Write(b)
|
||
}
|
||
|
||
func (m *MCS) Close() error {
|
||
return m.transport.Close()
|
||
}
|
||
|
||
type MCSClient struct {
|
||
*MCS
|
||
clientCoreData *gcc.ClientCoreData
|
||
clientNetworkData *gcc.ClientNetworkData
|
||
clientSecurityData *gcc.ClientSecurityData
|
||
// lowColorDepth：SetSessionColorDepth(16/24) 置位， Dynvc-GFX 能力位
|
||
// 需要跳过（该端点要求 32bpp 会话）
|
||
lowColorDepth bool
|
||
|
||
serverCoreData *gcc.ServerCoreData
|
||
serverNetworkData *gcc.ServerNetworkData
|
||
serverSecurityData *gcc.ServerSecurityData
|
||
|
||
channelsConnected int
|
||
userId uint16
|
||
nbChannelRequested int
|
||
pendingJoins int // 并行突发加入后尚未收到确认的 SVC 通道数
|
||
messageChannelId uint16 // from SC_MCS_MSGCHANNEL; 0 = not negotiated
|
||
messageChannelJoined bool
|
||
bwStartTime time.Time // timestamp of last RDP_BW_START for timeDelta calculation
|
||
}
|
||
|
||
func NewMCSClient(t core.Transport, kbdLayout uint32, keyboardType uint32, keyboardSubType uint32) *MCSClient {
|
||
c := &MCSClient{
|
||
MCS: NewMCS(t, SEND_DATA_INDICATION, SEND_DATA_REQUEST),
|
||
clientCoreData: gcc.NewClientCoreData(kbdLayout, keyboardType, keyboardSubType),
|
||
clientNetworkData: gcc.NewClientNetworkData(),
|
||
clientSecurityData: gcc.NewClientSecurityData(),
|
||
userId: 1 + MCS_USERCHANNEL_BASE,
|
||
}
|
||
c.transport.On("connect", c.connect)
|
||
return c
|
||
}
|
||
|
||
func (c *MCSClient) SetClientDesktop(width, height uint16) {
|
||
c.clientCoreData.DesktopWidth = width
|
||
c.clientCoreData.DesktopHeight = height
|
||
}
|
||
|
||
// SetClientName 覆盖客户端计算机名（ClientCoreData.ClientName，UTF-16LE，
|
||
// 字段共 32 字节，超长截断）。服务端按该名字管理 \\tsclient 重定向映射，
|
||
// 同名客户端残留（非正常断开）会让后续同名会话的映射失效——Explorer
|
||
// 打开 \\tsclient\<名> 报“试图访问无效的地址”且 rdpdr 通道零 IRP
|
||
// （RDPDR-2）。wasm 下 os.Hostname 回退值恒为 "js"，必须每次连接随机化。
|
||
func (c *MCSClient) SetClientName(name string) {
|
||
var buf [32]byte
|
||
copy(buf[:], core.UnicodeEncode(name))
|
||
c.clientCoreData.ClientName = buf
|
||
}
|
||
|
||
// SetSessionColorDepth 请求会话颜色位数（16/24/32，其它值按 32 处理）。
|
||
// 32bpp = highColorDepth 24BPP + WANT_32BPP_SESSION（mstsc 默认）；
|
||
// 16/24bpp 清除 WANT_32BPP_SESSION 并收紧 supportedColorDepths。
|
||
// 注意 RDPGFX 会话（RemoteFX/H264 模式）表面恒为 32bpp，此选项只在
|
||
// 传统位图管线生效。
|
||
// SetSessionColorDepth 请求会话颜色位数（16/24/32，其它值按 32 处理）。
|
||
// 实测（Win10 19041）三个坑：
|
||
// 1. supportedColorDepths 若不含 24/32bpp 支持位，服务器在 MCS 握手
|
||
// 阶段直接断连（无 ERRINFO）——支持位恒为全量（与 FreeRDP 一致）。
|
||
// 2. 低色深时必须同时清除 SUPPORT_DYNVC_GFX_PROTOCOL（0x200）：
|
||
// 该位声明 32bpp 的 Dynvc-GFX 端点，与 16bpp 会话矛盾，服务器会
|
||
// 进入不一致状态（fastpath SURFCMDS 泛滥、音频 DVC 不初始化）。
|
||
// SetClientDynvcProtocol 会在低色深时跳过该位（drdynvc 通道保留）。
|
||
// 3. 色深协商只通过 highColorDepth + postBeta2ColorDepth +
|
||
// WANT_32BPP_SESSION 位表达。
|
||
// 注意 RDPGFX 会话（RemoteFX/H264 模式）表面恒为 32bpp，此选项只在
|
||
// 传统位图管线生效。
|
||
func (c *MCSClient) SetSessionColorDepth(bpp int) {
|
||
d := c.clientCoreData
|
||
switch bpp {
|
||
case 16:
|
||
d.HighColorDepth = gcc.HIGH_COLOR_16BPP
|
||
d.PostBeta2ColorDepth = gcc.RNS_UD_COLOR_16BPP_565
|
||
d.EarlyCapabilityFlags &^= gcc.RNS_UD_CS_WANT_32BPP_SESSION |
|
||
gcc.RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL
|
||
c.lowColorDepth = true
|
||
case 24:
|
||
d.HighColorDepth = gcc.HIGH_COLOR_24BPP
|
||
d.PostBeta2ColorDepth = gcc.RNS_UD_COLOR_24BPP
|
||
d.EarlyCapabilityFlags &^= gcc.RNS_UD_CS_WANT_32BPP_SESSION |
|
||
gcc.RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL
|
||
c.lowColorDepth = true
|
||
default:
|
||
// 32bpp：保持 NewClientCoreData 的默认（WANT_32BPP_SESSION）
|
||
}
|
||
}
|
||
|
||
func (c *MCSClient) SetClientDynvcProtocol() {
|
||
// 低色深会话不支持 Dynvc-GFX 端点（见 SetSessionColorDepth），
|
||
// drdynvc 通道本身保留（剪贴板图片/音频 DVC 仍需要）。
|
||
if !c.lowColorDepth {
|
||
c.clientCoreData.EarlyCapabilityFlags |= gcc.RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL
|
||
}
|
||
c.clientNetworkData.AddVirtualChannel(drdynvc.ChannelName, drdynvc.ChannelOption)
|
||
}
|
||
|
||
func (c *MCSClient) SetClientRemoteProgram() {
|
||
c.clientNetworkData.AddVirtualChannel(rail.ChannelName, rail.ChannelOption)
|
||
}
|
||
|
||
func (c *MCSClient) SetClientSoundProtocol() {
|
||
c.clientNetworkData.AddVirtualChannel(rdpsnd.ChannelName, rdpsnd.ChannelOption)
|
||
}
|
||
|
||
func (c *MCSClient) SetClientDeviceRedirection() {
|
||
c.clientNetworkData.AddVirtualChannel("rdpdr",
|
||
uint32(gcc.CHANNEL_OPTION_INITIALIZED|gcc.CHANNEL_OPTION_ENCRYPT_RDP|gcc.CHANNEL_OPTION_COMPRESS_RDP))
|
||
}
|
||
|
||
func (c *MCSClient) SetClientClipboard() {
|
||
c.clientNetworkData.AddVirtualChannel("cliprdr",
|
||
uint32(gcc.CHANNEL_OPTION_INITIALIZED|gcc.CHANNEL_OPTION_ENCRYPT_RDP|gcc.CHANNEL_OPTION_COMPRESS_RDP))
|
||
}
|
||
|
||
func (c *MCSClient) connect(selectedProtocol uint32) {
|
||
slog.Debug("connect", "selectedProtocol", selectedProtocol)
|
||
c.clientCoreData.ServerSelectedProtocol = selectedProtocol
|
||
|
||
slog.Debug("connnect", "clientCoreData", c.clientCoreData)
|
||
slog.Debug("connect", "clientNetworkData", c.clientNetworkData)
|
||
slog.Debug("connect", "clientSecurityData", c.clientSecurityData)
|
||
// sendConnectclientCoreDataInitial
|
||
userDataBuff := bytes.Buffer{}
|
||
userDataBuff.Write(c.clientCoreData.Pack())
|
||
userDataBuff.Write(c.clientNetworkData.Pack())
|
||
userDataBuff.Write(c.clientSecurityData.Pack())
|
||
userDataBuff.Write(gcc.PackClientMsgChannelData())
|
||
|
||
slog.Debug("userData", "data", core.Hex(userDataBuff.Bytes()), "len", len(userDataBuff.Bytes()))
|
||
ccReq := gcc.MakeConferenceCreateRequest(userDataBuff.Bytes())
|
||
slog.Debug("ccReq", "data", core.Hex(ccReq), "len", len(ccReq))
|
||
connectInitial := NewConnectInitial(ccReq)
|
||
connectInitialBerEncoded := connectInitial.BER()
|
||
|
||
dataBuff := &bytes.Buffer{}
|
||
ber.WriteApplicationTag(uint8(MCS_TYPE_CONNECT_INITIAL), len(connectInitialBerEncoded), dataBuff)
|
||
dataBuff.Write(connectInitialBerEncoded)
|
||
slog.Debug("send connet initial", "data", core.Hex(dataBuff.Bytes()), "len", len(dataBuff.Bytes()))
|
||
|
||
_, err := c.transport.Write(dataBuff.Bytes())
|
||
if err != nil {
|
||
c.Emit("error", errors.New(fmt.Sprintf("mcs sendConnectInitial write error %v", err)))
|
||
return
|
||
}
|
||
slog.Debug("mcs wait for data event")
|
||
c.transport.Once("data", c.recvConnectResponse)
|
||
}
|
||
|
||
func (c *MCSClient) recvConnectResponse(s []byte) {
|
||
slog.Debug("mcs recvConnectResponse", "s", core.Hex(s))
|
||
cResp, err := ReadConnectResponse(bytes.NewReader(s))
|
||
if err != nil {
|
||
c.Emit("error", errors.New(fmt.Sprintf("ReadConnectResponse %v", err)))
|
||
return
|
||
}
|
||
// record server gcc block
|
||
serverSettings := gcc.ReadConferenceCreateResponse(cResp.userData)
|
||
for _, v := range serverSettings {
|
||
switch v.(type) {
|
||
case *gcc.ServerSecurityData:
|
||
c.serverSecurityData = v.(*gcc.ServerSecurityData)
|
||
|
||
case *gcc.ServerCoreData:
|
||
c.serverCoreData = v.(*gcc.ServerCoreData)
|
||
|
||
case *gcc.ServerNetworkData:
|
||
c.serverNetworkData = v.(*gcc.ServerNetworkData)
|
||
|
||
case *gcc.ServerMsgChannelData:
|
||
c.messageChannelId = v.(*gcc.ServerMsgChannelData).MCSChannelId
|
||
slog.Debug("SC_MCS_MSGCHANNEL", "messageChannelId", c.messageChannelId)
|
||
|
||
default:
|
||
slog.Warn("recvConnectResponse: unhandled server gcc block", "type", reflect.TypeOf(v))
|
||
}
|
||
}
|
||
c.sendErectDomainRequest()
|
||
c.sendAttachUserRequest()
|
||
|
||
c.transport.Once("data", c.recvAttachUserConfirm)
|
||
}
|
||
|
||
func (c *MCSClient) sendErectDomainRequest() {
|
||
buff := &bytes.Buffer{}
|
||
writeMCSPDUHeader(ERECT_DOMAIN_REQUEST, 0, buff)
|
||
per.WriteInteger(0, buff)
|
||
per.WriteInteger(0, buff)
|
||
c.transport.Write(buff.Bytes())
|
||
}
|
||
|
||
func (c *MCSClient) sendAttachUserRequest() {
|
||
buff := &bytes.Buffer{}
|
||
writeMCSPDUHeader(ATTACH_USER_REQUEST, 0, buff)
|
||
c.transport.Write(buff.Bytes())
|
||
}
|
||
|
||
func (c *MCSClient) recvAttachUserConfirm(s []byte) {
|
||
slog.Debug("mcs recvAttachUserConfirm", "s", core.Hex(s))
|
||
r := bytes.NewReader(s)
|
||
|
||
option, err := core.ReadUInt8(r)
|
||
if err != nil {
|
||
c.Emit("error", err)
|
||
return
|
||
}
|
||
|
||
if !readMCSPDUHeader(option, ATTACH_USER_CONFIRM) {
|
||
c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_BAD_HEADER"))
|
||
return
|
||
}
|
||
|
||
e, err := per.ReadEnumerates(r)
|
||
if err != nil {
|
||
c.Emit("error", err)
|
||
return
|
||
}
|
||
if e != 0 {
|
||
c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_SERVER_REJECT_USER'"))
|
||
return
|
||
}
|
||
|
||
userId, _ := per.ReadInteger16(r)
|
||
userId += MCS_USERCHANNEL_BASE
|
||
c.userId = userId
|
||
|
||
c.channels = append(c.channels, MCSChannelInfo{userId, "user"})
|
||
c.connectChannels()
|
||
}
|
||
|
||
func (c *MCSClient) connectChannels() {
|
||
slog.Debug("connectChannels", "channelsConnected", c.channelsConnected, "channels", c.channels)
|
||
if c.channelsConnected < len(c.channels) {
|
||
// sendChannelJoinRequest
|
||
c.sendChannelJoinRequest(c.channels[c.channelsConnected].ID)
|
||
|
||
c.transport.Once("data", c.recvChannelJoinConfirm)
|
||
return
|
||
}
|
||
|
||
// Join the message channel (for connect-time auto-detection) before SVCs.
|
||
if c.messageChannelId != 0 && !c.messageChannelJoined {
|
||
c.messageChannelJoined = true
|
||
c.sendChannelJoinRequest(c.messageChannelId)
|
||
c.transport.Once("data", c.recvChannelJoinConfirm)
|
||
return
|
||
}
|
||
|
||
if c.nbChannelRequested == 0 && int(c.serverNetworkData.ChannelCount) > 0 {
|
||
// 并行突发加入全部 SVC 静态通道（mstsc 同款）：原先串行逐个等
|
||
// 确认，rdpdr 排在队尾，其 join 在服务端 LogonNotify 之后 ~100ms
|
||
// 才完成——登录期驱动映射（winlogon→drprov 按"当时的设备表"创建
|
||
// \\TSCLIENT\<名> 连接）因此永远看不到我们的设备，`dir
|
||
// \\tsclient\<名>` 恒为"设备没有连接"(2250)。并行发送让 rdpdr
|
||
// 与其余通道同时就绪，抢在 LogonNotify 之前。
|
||
for i := 0; i < int(c.serverNetworkData.ChannelCount); i++ {
|
||
c.sendChannelJoinRequest(c.serverNetworkData.ChannelIdArray[i])
|
||
}
|
||
c.nbChannelRequested = int(c.serverNetworkData.ChannelCount)
|
||
c.pendingJoins = int(c.serverNetworkData.ChannelCount)
|
||
// 单个持久监听 + 计数：emission 对同一条数据事件会触发全部
|
||
// 监听器，N×Once 会在首个确认上重复消费（实测导致通道表重复
|
||
// 追加与 MCS opcode 错误），故用 Off 在计数归零后摘除。
|
||
c.transport.On("data", c.recvChannelJoinConfirm)
|
||
return
|
||
}
|
||
if c.pendingJoins > 0 {
|
||
// 并行突发确认进行中，由 recvChannelJoinConfirm 计数收尾。
|
||
return
|
||
}
|
||
c.transport.On("data", c.recvData)
|
||
// send client and sever gcc informations callback to sec
|
||
clientData := make([]any, 0)
|
||
clientData = append(clientData, c.clientCoreData)
|
||
clientData = append(clientData, c.clientSecurityData)
|
||
clientData = append(clientData, c.clientNetworkData)
|
||
|
||
serverData := make([]any, 0)
|
||
serverData = append(serverData, c.serverCoreData)
|
||
serverData = append(serverData, c.serverSecurityData)
|
||
c.Emit("connect", clientData, serverData, c.userId, c.channels)
|
||
}
|
||
|
||
func (c *MCSClient) sendChannelJoinRequest(channelId uint16) {
|
||
slog.Debug("sendChannelJoinRequest", "channelId", channelId)
|
||
buff := &bytes.Buffer{}
|
||
writeMCSPDUHeader(CHANNEL_JOIN_REQUEST, 0, buff)
|
||
per.WriteInteger16(c.userId-MCS_USERCHANNEL_BASE, buff)
|
||
per.WriteInteger16(channelId, buff)
|
||
c.transport.Write(buff.Bytes())
|
||
}
|
||
|
||
func (c *MCSClient) recvData(s []byte) {
|
||
r := bytes.NewReader(s)
|
||
option, err := core.ReadUInt8(r)
|
||
if err != nil {
|
||
c.Emit("error", err)
|
||
return
|
||
}
|
||
|
||
if readMCSPDUHeader(option, DISCONNECT_PROVIDER_ULTIMATUM) {
|
||
c.Emit("error", errors.New("MCS DISCONNECT_PROVIDER_ULTIMATUM"))
|
||
c.transport.Close()
|
||
return
|
||
} else if !readMCSPDUHeader(option, c.recvOpCode) {
|
||
c.Emit("error", errors.New("Invalid expected MCS opcode receive data"))
|
||
return
|
||
}
|
||
|
||
userId, _ := per.ReadInteger16(r)
|
||
userId += MCS_USERCHANNEL_BASE
|
||
|
||
channelId, _ := per.ReadInteger16(r)
|
||
per.ReadEnumerates(r)
|
||
size, _ := per.ReadLength(r)
|
||
// channel ID doesn't match a requested layer
|
||
found := false
|
||
channelName := ""
|
||
for _, channel := range c.channels {
|
||
if channel.ID == channelId {
|
||
found = true
|
||
channelName = channel.Name
|
||
break
|
||
}
|
||
}
|
||
if !found {
|
||
if c.messageChannelId != 0 && channelId == c.messageChannelId {
|
||
data, _ := core.ReadBytes(int(size), r)
|
||
c.handleAutoDetect(data)
|
||
return
|
||
}
|
||
slog.Error("mcs receive data for an unconnected layer")
|
||
return
|
||
}
|
||
left, err := core.ReadBytes(int(size), r)
|
||
if err != nil {
|
||
c.Emit("error", errors.New(fmt.Sprintf("mcs recvData get data error %v", err)))
|
||
return
|
||
}
|
||
c.Emit("sec", channelName, left)
|
||
}
|
||
|
||
func (c *MCSClient) recvChannelJoinConfirm(s []byte) {
|
||
slog.Debug("recvChannelJoinConfirm", "s", core.Hex(s))
|
||
r := bytes.NewReader(s)
|
||
option, err := core.ReadUInt8(r)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
if !readMCSPDUHeader(option, CHANNEL_JOIN_CONFIRM) {
|
||
// 并行突发窗口内同监听器会看到数据 PDU：静默忽略（由 recvData
|
||
// 在突发完成后接管处理）。
|
||
return
|
||
}
|
||
|
||
confirm, _ := per.ReadEnumerates(r)
|
||
userId, _ := per.ReadInteger16(r)
|
||
userId += MCS_USERCHANNEL_BASE
|
||
|
||
if c.userId != userId {
|
||
c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_INVALID_USER_ID"))
|
||
return
|
||
}
|
||
|
||
channelId, _ := per.ReadInteger16(r)
|
||
if (confirm != 0) && (channelId == uint16(MCS_GLOBAL_CHANNEL_ID) || channelId == c.userId) {
|
||
c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_SERVER_MUST_CONFIRM_STATIC_CHANNEL"))
|
||
return
|
||
}
|
||
if confirm == 0 {
|
||
for i := 0; i < int(c.serverNetworkData.ChannelCount); i++ {
|
||
if channelId == c.serverNetworkData.ChannelIdArray[i] {
|
||
var t MCSChannelInfo
|
||
t.ID = channelId
|
||
t.Name = string(c.clientNetworkData.ChannelDefArray[i].Name[:])
|
||
c.channels = append(c.channels, t)
|
||
}
|
||
}
|
||
}
|
||
c.channelsConnected++
|
||
if c.pendingJoins > 0 {
|
||
c.pendingJoins--
|
||
if c.pendingJoins > 0 {
|
||
return
|
||
}
|
||
// 全部 SVC 确认到齐：摘除突发期监听器，交还数据泵。
|
||
c.transport.Off("data", c.recvChannelJoinConfirm)
|
||
}
|
||
c.connectChannels()
|
||
}
|
||
|
||
// Connect-time auto-detection constants (MS-RDPBCGR 2.2.14).
|
||
const (
|
||
secAutoDetectReq = uint16(0x1000)
|
||
secAutoDetectRsp = uint16(0x2000)
|
||
|
||
rdpRttRequestConnecttime = uint16(0x1001)
|
||
rdpBwStartConnecttime = uint16(0x1014)
|
||
rdpBwPayload = uint16(0x0002)
|
||
rdpBwStopConnecttime = uint16(0x002B)
|
||
rdpRttRequest = uint16(0x0001) // continuous RTT request
|
||
rdpBwStart = uint16(0x0014) // continuous BW start (no response)
|
||
rdpBwStop = uint16(0x0429) // continuous BW stop
|
||
|
||
typeIDAutodetectResponse = uint8(0x01)
|
||
rdpRttResponseType = uint16(0x0000)
|
||
rdpBwResultsConnecttime = uint16(0x0003)
|
||
rdpBwResults = uint16(0x000B) // continuous BW results
|
||
)
|
||
|
||
// handleAutoDetect processes a connect-time auto-detect request from the server
|
||
// on the message channel. It responds to RTT and BW measurement requests so
|
||
// that gnome-remote-desktop proceeds to open the audio DVC channels.
|
||
func (c *MCSClient) handleAutoDetect(data []byte) {
|
||
r := bytes.NewReader(data)
|
||
secFlag, _ := core.ReadUint16LE(r)
|
||
core.ReadUint16LE(r) // secFlagHi
|
||
|
||
if secFlag&secAutoDetectReq == 0 {
|
||
return
|
||
}
|
||
|
||
_, _ = core.ReadUInt8(r) // headerLength
|
||
core.ReadUInt8(r) // headerTypeId
|
||
seqNum, _ := core.ReadUint16LE(r)
|
||
reqType, _ := core.ReadUint16LE(r)
|
||
|
||
switch reqType {
|
||
case rdpRttRequestConnecttime, rdpRttRequest:
|
||
c.sendAutoDetectResponse(seqNum, rdpRttResponseType, 0)
|
||
case rdpBwStartConnecttime, rdpBwStart:
|
||
c.bwStartTime = time.Now()
|
||
case rdpBwStopConnecttime:
|
||
elapsed := uint32(time.Since(c.bwStartTime).Milliseconds())
|
||
if elapsed == 0 {
|
||
elapsed = 1
|
||
}
|
||
c.sendAutoDetectResponse(seqNum, rdpBwResultsConnecttime, elapsed)
|
||
case rdpBwStop:
|
||
elapsed := uint32(time.Since(c.bwStartTime).Milliseconds())
|
||
if elapsed == 0 {
|
||
elapsed = 1
|
||
}
|
||
c.sendAutoDetectResponse(seqNum, rdpBwResults, elapsed)
|
||
// rdpBwPayload requires no response
|
||
}
|
||
}
|
||
|
||
// sendAutoDetectResponse sends an auto-detect response on the message channel.
|
||
// timeDelta is 0 for RTT responses (no BW fields); non-zero for BW responses
|
||
// (timeDelta in milliseconds since the corresponding BW_START was received).
|
||
func (c *MCSClient) sendAutoDetectResponse(sequenceNumber uint16, responseType uint16, timeDelta uint32) {
|
||
includeBW := responseType == rdpBwResultsConnecttime || responseType == rdpBwResults
|
||
headerLength := uint8(6)
|
||
if includeBW {
|
||
headerLength = 14
|
||
}
|
||
|
||
payload := &bytes.Buffer{}
|
||
core.WriteUInt16LE(secAutoDetectRsp, payload)
|
||
core.WriteUInt16LE(0, payload)
|
||
core.WriteUInt8(headerLength, payload)
|
||
core.WriteUInt8(typeIDAutodetectResponse, payload)
|
||
core.WriteUInt16LE(sequenceNumber, payload)
|
||
core.WriteUInt16LE(responseType, payload)
|
||
if includeBW {
|
||
core.WriteUInt32LE(timeDelta, payload) // timeDelta in milliseconds
|
||
core.WriteUInt32LE(0, payload) // byteCount (no BW_PAYLOAD was sent)
|
||
}
|
||
|
||
c.transport.Write(c.Pack(payload.Bytes(), c.messageChannelId))
|
||
}
|
||
|
||
func (c *MCSClient) Pack(data []byte, channelId uint16) []byte {
|
||
buff := &bytes.Buffer{}
|
||
writeMCSPDUHeader(c.sendOpCode, 0, buff)
|
||
per.WriteInteger16(c.userId-MCS_USERCHANNEL_BASE, buff)
|
||
per.WriteInteger16(channelId, buff)
|
||
core.WriteUInt8(0x70, buff)
|
||
per.WriteLength(len(data), buff)
|
||
core.WriteBytes(data, buff)
|
||
return buff.Bytes()
|
||
}
|
||
|
||
func (c *MCSClient) Write(data []byte) (n int, err error) {
|
||
data = c.Pack(data, c.channels[0].ID)
|
||
return c.transport.Write(data)
|
||
}
|
||
|
||
func (c *MCSClient) SendToChannel(channel string, data []byte) (n int, err error) {
|
||
channelId := c.channels[0].ID
|
||
for _, ch := range c.channels {
|
||
if channel == ch.Name {
|
||
channelId = ch.ID
|
||
break
|
||
}
|
||
}
|
||
|
||
data = c.Pack(data, channelId)
|
||
return c.transport.Write(data)
|
||
}
|