/// <summary> /// Constructor /// </summary> /// <param name="context"></param> public Rdpbcgr_DVCServerTransport(RdpbcgrServerSessionContext context) { this.sessionContext = context; if (sessionContext.SVCManager == null) { throw new NotSupportedException("Cannot get SVC from RDPBCGR connection for RDPEDYC, this transport must be created after RDPBCGR connection established."); } channel = sessionContext.SVCManager.GetChannelByName(StaticVirtualChannelName.RDPEDYC); if (channel == null) { throw new NotSupportedException("Cannot get SVC from RDPBCGR connection for RDPEDYC, the static virtual channel is not created."); } channel.Received += ReceivedBytes; if (!sessionContext.SVCManager.IsRunning) { // Better start the SVC manager here, so as to make sure the first packet of RDPEDYC can be processed // it is not same restrict as client, since the first packet is sent by server sessionContext.SVCManager.Start(); } decoder = new ServerDecodingPduBuilder(); pduBuilder = new PduBuilder(); }
/// <summary> /// Accept an existing RDP session which established outside. /// </summary> /// <param name="rdpbcgrServer">RdpbcgrServer object.</param> /// <param name="serverContext">RdpbcgrServerSessionContext object.</param> public void Accept(RdpbcgrServer rdpbcgrServer, RdpbcgrServerSessionContext serverContext) { this.rdpbcgrAdapter = Site.GetAdapter <IRdpbcgrAdapter>(); this.rdpbcgrServerStack = rdpbcgrServer; this.rdpbcgrSessionContext = serverContext; this.rdpbcgrAdapter.TS_FRAME_ACKNOWLEDGE_PDUReceived += new TS_FRAME_ACKNOWLEDGE_PDUHandler(this.VerifyTS_FRAME_ACKNOWLEDGE_PDU); }
/// <summary> /// Constructor /// </summary> /// <param name="connectedRdpServer"></param> /// <param name="context"></param> /// <param name="transportType"></param> public Rdpemt_DVCServerTransport(RdpbcgrServer connectedRdpServer, RdpbcgrServerSessionContext context, DynamicVC_TransportType transportType) { this.serverSessionContext = context; this.rdpbcgrServer = connectedRdpServer; this.transportProtocol = Multitransport_Protocol_value.INITITATE_REQUEST_PROTOCOL_UDPFECR; if (transportType == DynamicVC_TransportType.RDP_UDP_Lossy) { this.transportProtocol = Multitransport_Protocol_value.INITITATE_REQUEST_PROTOCOL_UDPFECL; } if (!serverSessionContext.IsClientMultitransportChannelDataRecieved) { throw new NotSupportedException("This RDP connection doesn't support multiple transport!"); } try { EstablishTransportConnection(); } catch (Exception) { // Ensure resource can be released properly if exception occurred in Constructor Dispose(); // Not suppress the exception, transfer the error to test result. throw; } decoder = new ServerDecodingPduBuilder(); pduBuilder = new PduBuilder(); }
public Server_Demand_Active_Pdu_Ex(Server_Demand_Active_Pdu orgPdu, RdpbcgrServerSessionContext serverSessionContext) : base(serverSessionContext) { this.commonHeader = orgPdu.commonHeader; //this.commonHeader.tpktHeader = orgPdu.commonHeader.tpktHeader; //this.commonHeader.x224Data = orgPdu.commonHeader.x224Data; //this.commonHeader.securityHeader = orgPdu.commonHeader.securityHeader; this.demandActivePduData = orgPdu.demandActivePduData; }
/// <summary> /// Only on RDPEUDP Server can exist /// </summary> /// <param name="context"></param> private void CreateRdpeudpServer(RdpbcgrServerSessionContext context) { if (rdpeudpServer == null) { rdpeudpServer = new RdpeudpServer((IPEndPoint)context.LocalIdentity); } //if (!rdpeudpServer.Running) rdpeudpServer.Start(); }
/// <summary> /// Remove session context from server context. If connection does not exists, do nothing. /// </summary> /// <param name="sessionContext">Add session context.</param> internal void RemoveSession(RdpbcgrServerSessionContext sessionContext) { lock (this.sessions) { if (this.SessionContexts.Contains(sessionContext)) { this.sessions.Remove(sessionContext); } } }
/// <summary> /// Add session context to server context. /// </summary> /// <param name="sessionContext">Add session context.</param> internal void AddSession(RdpbcgrServerSessionContext sessionContext) { lock (this.sessions) { if (this.sessions.Contains(sessionContext)) { throw new InvalidOperationException( "the sessionContext is exists in the sessionContext collection, can not add duplicate sessionContext"); } this.sessions.Add(sessionContext); } }
/// <summary> /// Only on RDPEUDP Server can exist /// </summary> /// <param name="context"></param> private static void CreateRdpeudpServer(RdpbcgrServerSessionContext context) { if (rdpeudpServer == null) { lock (rdpeudpServerLock) { if (rdpeudpServer == null) { rdpeudpServer = new RdpeudpServer((IPEndPoint)context.LocalIdentity); rdpeudpServer.Start(); } } } }
public static TS_FP_UPDATE_PDU CreateFPUpdatePDU(RdpbcgrServerSessionContext context, TS_FP_UPDATE update) { TS_FP_UPDATE_PDU fpOutput = new TS_FP_UPDATE_PDU(context); fpOutput.fpOutputHeader = new nested_TS_FP_UPDATE_PDU_fpOutputHeader(); fpOutput.dataSignature = null; fpOutput.length1 = 0; fpOutput.length2 = 0; fpOutput.fpOutputUpdates = new TS_FP_UPDATE[1]; fpOutput.fpOutputUpdates[0] = update; return(fpOutput); }
public static TS_FP_UPDATE_PDU CreateFPUpdatePDU(RdpbcgrServerSessionContext context, TS_FP_UPDATE update) { TS_FP_UPDATE_PDU fpOutput = new TS_FP_UPDATE_PDU(context); fpOutput.fpOutputHeader = (byte)(((int)nested_TS_FP_UPDATE_PDU_fpOutputHeader_actionCode_Values.FASTPATH_OUTPUT_ACTION_FASTPATH & 0x03) | ((int)((int)reserved_Values.V1 & 0x0f) << 2)); fpOutput.dataSignature = null; fpOutput.length1 = 0; fpOutput.length2 = 0; fpOutput.fpOutputUpdates = new TS_FP_UPDATE[1]; fpOutput.fpOutputUpdates[0] = update; return(fpOutput); }
/// <summary> /// Constructor /// </summary> /// <param name="server"></param> /// <param name="context"></param> public RdpedycServer(RdpbcgrServer server, RdpbcgrServerSessionContext context, bool autoCloseChannel = true) { this.rdpbcgrServer = server; this.sessionContext = context; transportDic = new Dictionary <DynamicVC_TransportType, IDVCTransport>(); unprocessedDVCPacketBuffer = new List <UnprocessedDVCPDUInfo>(); Rdpbcgr_DVCServerTransport transport = new Rdpbcgr_DVCServerTransport(context); channelDicbyId = new Dictionary <uint, DynamicVirtualChannel>(); pduBuilder = new PduBuilder(); transport.Received += ProcessPacketFromTCP; transportDic.Add(DynamicVC_TransportType.RDP_TCP, transport); this.autoCloseChannel = autoCloseChannel; }
public SlowPathOutputPduEx(SlowPathOutputPdu orgPdu, RdpbcgrServerSessionContext serverSessionContext) : base(serverSessionContext) { this.commonHeader = orgPdu.commonHeader; if (orgPdu.slowPathUpdates != null) { Collection <RdpbcgrSlowPathUpdatePdu> updates = new Collection <RdpbcgrSlowPathUpdatePdu>(); for (int i = 0; i < orgPdu.slowPathUpdates.Length; ++i) { updates.Add(orgPdu.slowPathUpdates[i]); } this.slowPathUpdates = new RdpbcgrSlowPathUpdatePdu[updates.Count]; for (int i = 0; i < updates.Count; ++i) { this.slowPathUpdates[i] = updates[i]; } } }
/// <summary> /// Constructor /// </summary> /// <param name="connectedRdpServer"></param> /// <param name="context"></param> /// <param name="transportType"></param> public Rdpemt_DVCServerTransport(RdpbcgrServer connectedRdpServer, RdpbcgrServerSessionContext context, DynamicVC_TransportType transportType) { this.serverSessionContext = context; this.rdpbcgrServer = connectedRdpServer; this.transportProtocol = Multitransport_Protocol_value.INITITATE_REQUEST_PROTOCOL_UDPFECR; if (transportType == DynamicVC_TransportType.RDP_UDP_Lossy) { this.transportProtocol = Multitransport_Protocol_value.INITITATE_REQUEST_PROTOCOL_UDPFECL; } if (!serverSessionContext.IsClientMultitransportChannelDataRecieved) { throw new NotSupportedException("This RDP connection doesn't support multiple transport!"); } EstablishTransportConnection(); decoder = new ServerDecodingPduBuilder(); pduBuilder = new PduBuilder(); }
internal static void EncodeSlowPathPdu(List <byte> sendBuffer, SlowPathPduCommonHeader commonHeader, byte[] dataBody, RdpbcgrServerSessionContext context) { EncodeStructure(sendBuffer, commonHeader.tpktHeader); EncodeStructure(sendBuffer, commonHeader.x224Data); List <byte> securityBuffer = new List <byte>(); EncodeSecurityData(securityBuffer, commonHeader.securityHeader, dataBody, context); SendDataIndication securityExchange = new SendDataIndication(new UserId(commonHeader.initiator), new ChannelId(commonHeader.channelId), new DataPriority(ConstValue.SEND_DATA_REQUEST_PRIORITY), ConstValue.SEND_DATA_REQUEST_SEGMENTATION, new Asn1OctetString(securityBuffer.ToArray())); DomainMCSPDU mcsDomain = new DomainMCSPDU(DomainMCSPDU.sendDataIndication, securityExchange); EncodeDomainMcsPdu(sendBuffer, mcsDomain); }
/// <summary> /// Constructor /// </summary> /// <param name="context"></param> public ServerStaticVirtualChannelManager(RdpbcgrServerSessionContext context) { this.context = context; this.channelDicById = new Dictionary <ushort, StaticVirtualChannel>(); this.channelDicByName = new Dictionary <string, StaticVirtualChannel>(); ushort[] virtualChannelIds = context.VirtualChannelIdStore; CHANNEL_DEF[] virtualChannelDefines = context.VirtualChannelDefines; if (virtualChannelIds != null && virtualChannelDefines != null && virtualChannelIds.Length == virtualChannelDefines.Length) { CompressionType compressType = context.VirtualChannelSCCompressionType; if (context.CompressionTypeSupported == CompressionType.PACKET_COMPR_TYPE_NONE) { compressType = CompressionType.PACKET_COMPR_TYPE_NONE; } else if (context.CompressionTypeSupported == CompressionType.PACKET_COMPR_TYPE_RDP6 || context.CompressionTypeSupported == CompressionType.PACKET_COMPR_TYPE_RDP61) { compressType = CompressionType.PACKET_COMPR_TYPE_64K; } for (int i = 0; i < virtualChannelIds.Length; ++i) { string name = virtualChannelDefines[i].name; if (name != null) { name = name.Replace("\0", string.Empty).ToUpper(); } StaticVirtualChannel channel = new ServerStaticVirtualChannel(virtualChannelIds[i], name, virtualChannelDefines[i].options, context.VCChunkSize, compressType, context.VirtualChannelCSCompressionType, SendPacket); channelDicById.Add(virtualChannelIds[i], channel); channelDicByName.Add(name, channel); } } }
/// <summary> /// Expect a packet /// </summary> /// <typeparam name="T"></typeparam> /// <param name="session"></param> /// <param name="waitTimeSpan"></param> /// <returns></returns> private T ExpectPacket <T>(RdpbcgrServerSessionContext session, TimeSpan waitTimeSpan) where T : StackPacket { DateTime endTime = DateTime.Now + waitTimeSpan; object receivedPdu = null; while (waitTimeSpan.TotalMilliseconds > 0) { try { receivedPdu = this.rdpbcgrServerStack.ExpectPdu(session, waitTimeSpan); } catch (TimeoutException) { } if (receivedPdu is T) { return((T)receivedPdu); } waitTimeSpan = endTime - DateTime.Now; } throw new TimeoutException("Timeout when expecting " + typeof(T).Name + " message."); }
/// <summary> /// Establish RDP Connection /// </summary> private void EstablishRDPConnection() { sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); #region Connection Initial x224ConnectionRequest = ExpectPacket <Client_X_224_Connection_Request_Pdu>(sessionContext, timeout); Server_X_224_Connection_Confirm_Pdu confirmPdu = rdpbcgrServerStack.CreateX224ConnectionConfirmPdu(sessionContext, selectedProtocols_Values.PROTOCOL_RDP_FLAG, RDP_NEG_RSP_flags_Values.DYNVC_GFX_PROTOCOL_SUPPORTED | RDP_NEG_RSP_flags_Values.EXTENDED_CLIENT_DATA_SUPPORTED); SendPdu(confirmPdu); if (bool.Parse(detectInfo.IsWindowsImplementation)) { RdpbcgrServerSessionContext orgSession = sessionContext; sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); if (sessionContext.Identity == orgSession.Identity) { sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); } x224ConnectionRequest = ExpectPacket <Client_X_224_Connection_Request_Pdu>(sessionContext, timeout); confirmPdu = rdpbcgrServerStack.CreateX224ConnectionConfirmPdu(sessionContext, selectedProtocols_Values.PROTOCOL_RDP_FLAG, RDP_NEG_RSP_flags_Values.DYNVC_GFX_PROTOCOL_SUPPORTED | RDP_NEG_RSP_flags_Values.EXTENDED_CLIENT_DATA_SUPPORTED); SendPdu(confirmPdu); } #endregion Connection Initial #region Basic Setting Exchange mscConnectionInitialPDU = ExpectPacket <Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request>(sessionContext, timeout); SERVER_CERTIFICATE cert = null; int certLen = 0; int dwKeysize = 2048; byte[] privateExp, publicExp, modulus; cert = rdpbcgrServerStack.GenerateCertificate(dwKeysize, out privateExp, out publicExp, out modulus); certLen = 120 + dwKeysize / 8; Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response connectRespPdu = rdpbcgrServerStack.CreateMCSConnectResponsePduWithGCCConferenceCreateResponsePdu( sessionContext, EncryptionMethods.ENCRYPTION_METHOD_128BIT, EncryptionLevel.ENCRYPTION_LEVEL_LOW, cert, certLen, MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECL | MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECR); SendPdu(connectRespPdu); sessionContext.ServerPrivateExponent = new byte[privateExp.Length]; Array.Copy(privateExp, sessionContext.ServerPrivateExponent, privateExp.Length); #endregion Basic Setting Exchange #region Channel Connection ExpectPacket <Client_MCS_Erect_Domain_Request>(sessionContext, timeout); ExpectPacket <Client_MCS_Attach_User_Request>(sessionContext, timeout); Server_MCS_Attach_User_Confirm_Pdu attachUserConfirmPdu = rdpbcgrServerStack.CreateMCSAttachUserConfirmPdu(sessionContext); SendPdu(attachUserConfirmPdu); //Join Channel int channelNum = 2; if (sessionContext.VirtualChannelIdStore != null) { channelNum += sessionContext.VirtualChannelIdStore.Length; } if (sessionContext.IsServerMessageChannelDataSend) { channelNum++; } for (int i = 0; i < channelNum; i++) { Client_MCS_Channel_Join_Request channelJoinPdu = ExpectPacket <Client_MCS_Channel_Join_Request>(sessionContext, timeout); Server_MCS_Channel_Join_Confirm_Pdu channelJoinResponse = rdpbcgrServerStack.CreateMCSChannelJoinConfirmPdu( sessionContext, channelJoinPdu.mcsChannelId); SendPdu(channelJoinResponse); } #endregion Channel Connection #region RDP Security Commencement securityExchangePDU = ExpectPacket <Client_Security_Exchange_Pdu>(sessionContext, timeout); #endregion RDP Security Commencement #region Secure Setting Exchange clientInfoPDU = ExpectPacket <Client_Info_Pdu>(sessionContext, timeout); #endregion Secure Setting Exchange #region Licensing Server_License_Error_Pdu_Valid_Client licensePdu = rdpbcgrServerStack.CreateLicenseErrorMessage(sessionContext); SendPdu(licensePdu); #endregion Licensing #region Capabilities Exchange RdpbcgrCapSet capSet = new RdpbcgrCapSet(); capSet.GenerateCapabilitySets(); Server_Demand_Active_Pdu demandActivePdu = rdpbcgrServerStack.CreateDemandActivePdu(sessionContext, capSet.CapabilitySets); SendPdu(demandActivePdu); confirmActivePDU = ExpectPacket <Client_Confirm_Active_Pdu>(sessionContext, timeout); clientCapSet = new RdpbcgrCapSet(); clientCapSet.CapabilitySets = confirmActivePDU.confirmActivePduData.capabilitySets; #endregion Capabilities Exchange #region Connection Finalization ExpectPacket <Client_Synchronize_Pdu>(sessionContext, timeout); Server_Synchronize_Pdu synchronizePdu = rdpbcgrServerStack.CreateSynchronizePdu(sessionContext); SendPdu(synchronizePdu); Server_Control_Pdu controlCooperatePdu = rdpbcgrServerStack.CreateControlCooperatePdu(sessionContext); SendPdu(controlCooperatePdu); ExpectPacket <Client_Control_Pdu_Cooperate>(sessionContext, timeout); ExpectPacket <Client_Control_Pdu_Request_Control>(sessionContext, timeout); Server_Control_Pdu controlGrantedPdu = rdpbcgrServerStack.CreateControlGrantedPdu(sessionContext); SendPdu(controlGrantedPdu); ITsCapsSet cap = this.clientCapSet.FindCapSet(capabilitySetType_Values.CAPSTYPE_BITMAPCACHE_REV2); if (cap != null) { TS_BITMAPCACHE_CAPABILITYSET_REV2 bitmapCacheV2 = (TS_BITMAPCACHE_CAPABILITYSET_REV2)cap; if ((bitmapCacheV2.CacheFlags & CacheFlags_Values.PERSISTENT_KEYS_EXPECTED_FLAG) != 0) { ExpectPacket <Client_Persistent_Key_List_Pdu>(sessionContext, timeout); } } ExpectPacket <Client_Font_List_Pdu>(sessionContext, timeout); Server_Font_Map_Pdu fontMapPdu = rdpbcgrServerStack.CreateFontMapPdu(sessionContext); SendPdu(fontMapPdu); #endregion Connection Finalization // Init for RDPEDYC try { rdpedycServer = new RdpedycServer(rdpbcgrServerStack, sessionContext); rdpedycServer.ExchangeCapabilities(timeout); } catch (Exception) { rdpedycServer = null; } }
public Virtual_Channel_RAW_Server_Pdu_Ex(Virtual_Channel_RAW_Server_Pdu orgPdu, RdpbcgrServerSessionContext serverSessionContext) : base(serverSessionContext) { this.commonHeader = orgPdu.commonHeader; this.channelPduHeader = orgPdu.channelPduHeader; this.virtualChannelData = orgPdu.virtualChannelData; }
public Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response_Ex(Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response orgPdu, RdpbcgrServerSessionContext serverSessionContext, NegativeType invalidType) : base(serverSessionContext) { this.tpktHeader = orgPdu.tpktHeader; this.x224Data = orgPdu.x224Data; this.mcsCrsp = orgPdu.mcsCrsp; this.invalidType = invalidType; }
internal static void EncodeSecurityData(List <byte> buffer, TS_SECURITY_HEADER securityHeader, byte[] dataBody, RdpbcgrServerSessionContext context) { if (securityHeader != null) // have a security header { EncodeStructure(buffer, (ushort)securityHeader.flags); EncodeStructure(buffer, securityHeader.flagsHi); if (securityHeader.GetType() == typeof(TS_SECURITY_HEADER1)) // non-fips security header { if (dataBody != null && context != null) { TS_SECURITY_HEADER1 nonFipsHeader = securityHeader as TS_SECURITY_HEADER1; byte[] dataSignature = null; bool isSalted = (nonFipsHeader.flags & TS_SECURITY_HEADER_flags_Values.SEC_SECURE_CHECKSUM) == TS_SECURITY_HEADER_flags_Values.SEC_SECURE_CHECKSUM; context.ServerEncrypt(dataBody, isSalted, out dataBody, out dataSignature); // If the data signature has not been set, generate it. // Otherwise, keep the old value. if (nonFipsHeader.dataSignature == null) { nonFipsHeader.dataSignature = dataSignature; } EncodeBytes(buffer, nonFipsHeader.dataSignature); } } else if (securityHeader.GetType() == typeof(TS_SECURITY_HEADER2)) // fips security header { if (dataBody != null && context != null) { TS_SECURITY_HEADER2 fipsHeader = securityHeader as TS_SECURITY_HEADER2; byte[] dataSignature = null; EncodeStructure(buffer, (ushort)fipsHeader.length); EncodeStructure(buffer, fipsHeader.version); // If the padlen equals 0, calculate it. // Otherwise, keep the old value. if (fipsHeader.padlen == 0) { fipsHeader.padlen = (byte)(ConstValue.TRIPLE_DES_PAD - (dataBody.Length % ConstValue.TRIPLE_DES_PAD)); } EncodeStructure(buffer, fipsHeader.padlen); context.ServerEncrypt(dataBody, false, out dataBody, out dataSignature); // If the data signature has not been set, generate it. // Otherwise, keep the old value. if (fipsHeader.dataSignature == null) { fipsHeader.dataSignature = dataSignature; } EncodeBytes(buffer, fipsHeader.dataSignature); } } } EncodeBytes(buffer, dataBody); }
private void AcceptLoopInternal() { listenSock = new Socket(config.LocalIpAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); var streamType = config.StreamType; var endPoint = new IPEndPoint(config.LocalIpAddress, config.LocalIpPort); listenSock.Bind(endPoint); listenSock.Listen(config.MaxConnections); UpdateSocketBlockingMode(listenSock, false); while (!acceptThreadCancellationTokenSource.IsCancellationRequested) { if (this.receivingStreams.Count >= config.MaxConnections) { // not listen untill the current connections are less than the max value. // the interval to query is 1 seconds: Thread.Sleep(1000); continue; } Socket socket = null; try { socket = this.listenSock.Accept(); UpdateSocketBlockingMode(socket, true); } catch (SocketException socketException) { if (socketException.SocketErrorCode == SocketError.WouldBlock) { continue; } throw; } TransportEvent connectEvent; Stream receiveStream = null; Stream baseStream = new NetworkStream(socket); switch (streamType) { case SecurityStreamType.None: receiveStream = baseStream; break; case SecurityStreamType.CredSsp: string targetSPN = ConstValue.CREDSSP_SERVER_NAME_PREFIX + config.LocalIpAddress; var csspServer = new CsspServer(new ETWStream(baseStream)); var credSspStream = csspServer.GetStream(); csspServer.Authenticate(cert, targetSPN); receiveStream = credSspStream; break; default: receiveStream = baseStream; break; } // Start receive thread with non-blocking mode. UpdateSocketBlockingMode(socket, false); RdpbcgrReceiveThread receiveThread = new RdpbcgrReceiveThread( socket.RemoteEndPoint, this.packetQueue, this.decoder, receiveStream, this.config.BufferSize ); connectEvent = new TransportEvent(EventType.Connected, socket.RemoteEndPoint, null); RdpbcgrServerSessionContext session = new RdpbcgrServerSessionContext(); session.Identity = connectEvent.EndPoint; session.Server = this.rdpbcgrServer; session.LocalIdentity = socket.LocalEndPoint; session.IsClientToServerEncrypted = this.rdpbcgrServer.IsClientToServerEncrypted; this.rdpbcgrServer.ServerContext.AddSession(session); this.packetQueue.AddObject(connectEvent); lock (this.receivingStreams) { this.receivingStreams.Add(socket, receiveThread); } receiveThread.Start(); } }
/// <summary> /// Creates a new Socket for a newly created connection and a new thread to receive packet in the loop. /// </summary> private void AcceptLoop() { while (!exitLoop) { if (this.receivingStreams.Count >= config.MaxConnections) { // not listen untill the current connections are less than the max value. // the interval to query is 1 seconds: Thread.Sleep(1000); continue; } Socket socket = null; try { socket = this.listenSock.Accept(); } catch (SocketException) { exitLoop = true; continue; } TransportEvent connectEvent; Stream receiveStream = null; Stream baseStream = new NetworkStream(socket); switch (streamType) { case SecurityStreamType.None: receiveStream = baseStream; break; case SecurityStreamType.Ssl: receiveStream = new SslStream( new ETWStream( baseStream), false ); ((SslStream)receiveStream).AuthenticateAsServer(cert); break; case SecurityStreamType.CredSsp: string targetSPN = ConstValue.CREDSSP_SERVER_NAME_PREFIX + config.LocalIpAddress; var csspServer = new CsspServer(new ETWStream(baseStream)); var credSspStream = csspServer.GetStream(); csspServer.Authenticate(cert, targetSPN); receiveStream = credSspStream; break; default: receiveStream = baseStream; break; } RdpbcgrReceiveThread receiveThread = new RdpbcgrReceiveThread( socket.RemoteEndPoint, this.packetQueue, this.decoder, receiveStream, this.config.BufferSize, this.rdpbcgrServer); connectEvent = new TransportEvent(EventType.Connected, socket.RemoteEndPoint, null); RdpbcgrServerSessionContext session = new RdpbcgrServerSessionContext(); session.Identity = connectEvent.EndPoint; session.Server = this.rdpbcgrServer; session.LocalIdentity = socket.LocalEndPoint; session.IsClientToServerEncrypted = this.rdpbcgrServer.IsClientToServerEncrypted; this.rdpbcgrServer.ServerContext.AddSession(session); this.packetQueue.AddObject(connectEvent); lock (this.receivingStreams) { this.receivingStreams.Add(socket, receiveThread); } receiveThread.Start(); } }
public Server_License_Error_Pdu_Valid_Client_Ex(Server_License_Error_Pdu_Valid_Client orgPdu, RdpbcgrServerSessionContext serverSessionContext) : base(serverSessionContext) { this.commonHeader = orgPdu.commonHeader; this.preamble = orgPdu.preamble; this.validClientMessage = orgPdu.validClientMessage; }