public ConnectedClientForm(LSClient client, ServerInfoMessage serverInfo) { InitializeComponent(); this.client = client; categorySelector.Categories = serverInfo.FileCategories; requestManager = new RequestManager(client); }
private void SetServerInfo(ServerInfoMessage message) { this.ServerIP = message.ServerIP; this.ServerPort = message.ServerPort; if (this.ServerInfoChange != null) { this.ServerInfoChange(this, null); } }
/// <summary> /// Sends the <see cref="ServerInfoMessage"/> structure to the connected client. /// </summary> /// <param name="info">The info message to send.</param> /// <returns>True on success.</returns> public bool SendServerInfo(ServerInfoMessage info) { _packet.Reset((ushort)RoutingID.ServerInfo, 0); if (info.Write(_packet)) { _packet.FinalisePacket(); return(Add(_packet) > 0); } return(false); }
private void ShowServerInfo(ServerInfoMessage info) { Console.WriteLine("Server info"); Console.WriteLine(string.Format(" Coordinate frame: {0} ({1})", info.CoordinateFrame.ToString(), info.IsLeftHanded ? "left" : "right")); Console.WriteLine(string.Format(" Time unit: {0}", TimeString(info.TimeUnit))); Console.WriteLine(string.Format(" Default time: {0} {1} Hz", TimeString(info.DefaultFrameTime * info.TimeUnit), 1e6 / (info.DefaultFrameTime * info.TimeUnit))); }
public static void TestShape(Shape reference, CreateShapeFunction createShape, ShapeValidationFunction validate) { ServerInfoMessage info = ServerInfoMessage.Default; info.CoordinateFrame = CoordinateFrame.XYZ; ServerSettings serverSettings = ServerSettings.Default; serverSettings.Flags &= ~(ServerFlag.Collate | ServerFlag.Compress); serverSettings.PortRange = 1000; IServer server = new TcpServer(serverSettings); // std::cout << "Start on port " << serverSettings.listenPort << std::endl; Assert.True(server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous)); // std::cout << "Server listening on port " << server.connectionMonitor()->port() << std::endl;; // Create client and connect. TcpClient client = new TcpClient("127.0.0.1", server.ConnectionMonitor.Port); // Wait for connection. if (server.ConnectionMonitor.WaitForConnections(5000u) > 0) { server.ConnectionMonitor.CommitConnections(null); } Assert.True(server.ConnectionCount > 0); Assert.True(client.Connected); // Send server messages from another thread. Otherwise large packets may block. Thread sendThread = new Thread(() => { Assert.True(server.Create(reference) > 0); Assert.True(server.UpdateTransfers(0) >= 0); Assert.True(server.UpdateFrame(0.0f) > 0); // Send end message. ControlMessage ctrlMsg = new ControlMessage(); Assert.True(ServerUtil.SendMessage(server, (ushort)RoutingID.Control, (ushort)ControlMessageID.End, ctrlMsg) > 0); Assert.True(server.UpdateFrame(0.0f) > 0); }); sendThread.Start(); // Process client messages. ValidateClient(client, reference, info, createShape, validate); client.Close(); sendThread.Join(); server.Close(); server.ConnectionMonitor.Stop(); server.ConnectionMonitor.Join(); }
public ExistingArchivesForm(ServerInfoMessage serverInfo) { InitializeComponent(); double availableGb = Math.Round( serverInfo.AvailableCapacityInBytes / Math.Pow(1024, 3), 1); double totalGb = Math.Round( serverInfo.TotalCapacityInBytes / Math.Pow(1024, 3), 1); availableMemLabel.Text = availableGb.ToString(); totalMemLabel.Text = totalGb.ToString(); }
/// <summary> /// Decode the <see cref="Tes.Net.ServerInfoMessage" /> packet. /// </summary> /// <param name="packet">The packet containing a <c>ServerInfoMessage</c></param> private void HandleServerInfo(PacketBuffer packet) { NetworkReader packetReader = new NetworkReader(packet.CreateReadStream(true)); ServerInfoMessage serverInfo = new ServerInfoMessage(); if (serverInfo.Read(packetReader)) { _defaultFrameTime = serverInfo.DefaultFrameTime; _timeUnit = serverInfo.TimeUnit; } }
IServer InitialiseServer() { ServerSettings serverSettings = ServerSettings.Default; ServerInfoMessage info = ServerInfoMessage.Default; serverSettings.ListenPort = TestPort; info.CoordinateFrame = ServerCoordinateFrame; //serverSettings.Flags |= ServerFlag.Compress; return(new TcpServer(serverSettings)); }
public void HandleServerInfoRequest(ServerInfoRequestMessage request, IFileCategorizationStrategy categorizationStrategy) { string drive = FileOperations.GetDriveFromPath(logsDestPath); ServerInfoMessage serverInfo = new ServerInfoMessage( FileOperations.GetLogCategories(logsSourcePath, categorizationStrategy), FileOperations.GetFileNamesInDirectory(logsDestPath, ".zip"), FileOperations.GetDriveAvailableBytes(drive), FileOperations.GetDriveTotalBytes(drive)); client.Writer.Write(serverInfo); logger.Log("Sent server info:"); logger.Log(serverInfo.ToString(true)); }
private async void connectButton_Click(object sender, EventArgs e) { connectButton.Enabled = false; LSClient client = new LSClient(); if (await client.TryConnectAsync(IPAddress.Parse(selectedConnection.ConnectionIP), 1337)) { Console.WriteLine("Waiting for server info..."); ServerInfoMessage serverInfo = await new RequestManager(client).RetrieveServerInfo(); //Console.WriteLine("Received server info: " + // JsonConvert.SerializeObject(serverInfo, Formatting.Indented)); new ConnectedClientForm(client, serverInfo).ShowDialog(this); client.Close(); } connectButton.Enabled = true; }
/// <summary> /// Sends the given <see cref="ServerInfoMessage"/> to the client. /// </summary> /// <param name="info">Details of the server to send to the client.</param> /// <remarks> /// Should always be send as the first message to the client. /// </remarks> public bool SendServerInfo(ServerInfoMessage info) { _serverInfo = info; const float secondsToMicroseconds = 1e6f; _secondsToTimeUnit = secondsToMicroseconds / (_serverInfo.TimeUnit != 0 ? _serverInfo.TimeUnit : 1.0f); if (Connected) { _packetLock.Lock(); try { _packet.Reset((ushort)RoutingID.ServerInfo, 0); if (info.Write(_packet)) { _packet.FinalisePacket(); _sendLock.Lock(); try { // Do not use collation buffer or compression for this message. if (_client != null && _client.Connected) { _client.GetStream().Write(_packet.Data, _packet.Cursor, _packet.Count); } return(true); } catch (System.IO.IOException) { _client.Close(); _client = null; } finally { _sendLock.Unlock(); } } } finally { _packetLock.Unlock(); } } return(false); }
public void ServerInfo() { var msg = new ServerInfoMessage(new ServerInfo(new ServerSettings { ServerLogo = "logo", Name = "name", Description = "description" }, new GuestUserProvider())); msg.WritePayload(serverContext, writer); long length = stream.Position; stream.Position = 0; msg = new ServerInfoMessage(); msg.ReadPayload(clientContext, reader); Assert.AreEqual(length, stream.Position); }
/// <summary> /// Functionality:This method do following things /// 1-SenderID=-1 represent its send by server /// 2-Send all participant list of running conference by assinging infoMsg.AttendeeProfileList=ClientList /// infoMsg.AttendeeProfileList is HashTable /// 3-Receive message to a particular id /// Status : This function is not using anywhere in the code. /// /// </summary> /// <param name="receiver"></param> private void SendUserListUpdateMessage(IMessageReceiver receiver) { ServerInfoMessage infoMsg = new ServerInfoMessage(); infoMsg.SenderID=-1; infoMsg.AttendeeProfileList = ClientList; // ((IMessageReceiver) this._dispatcher.TransparentProxy).ReceiveMessage(infoMsg); receiver.ReceiveMessage(infoMsg); infoMsg = null; // GC }
static void Main(string[] args) { //if (HaveOption("help", args)) //{ // ShowUsage(); // return; //} Console.CancelKeyPress += new ConsoleCancelEventHandler(ControlCHandler); ServerSettings serverSettings = ServerSettings.Default; ServerInfoMessage info = ServerInfoMessage.Default; info.CoordinateFrame = CoordinateFrame.XYZ; serverSettings.Flags |= ServerFlag.Collate; serverSettings.Flags |= ServerFlag.Compress; IServer server = new TcpServer(serverSettings); const int targetFrameTimeMs = 1000 / 5; int updateElapsedMs = 0; Vector3 offset = Vector3.Zero; float dt = 0; float time = 0; Stopwatch frameTimer = new Stopwatch(); Stopwatch sleepTimer = new Stopwatch(); server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous); frameTimer.Start(); while (!Quit) { frameTimer.Stop(); dt = frameTimer.ElapsedMilliseconds * 1e-3f; time += dt; frameTimer.Reset(); frameTimer.Start(); sleepTimer.Reset(); sleepTimer.Start(); if (server.ConnectionMonitor.Mode == ConnectionMonitorMode.Synchronous) { server.ConnectionMonitor.MonitorConnections(); } server.ConnectionMonitor.CommitConnections(OnNewConnection); server.UpdateTransfers(0); server.UpdateFrame(dt); offset.X += 0.05f; if (offset.X >= 1.0f) { offset.X = 0.0f; } ManyBoxes(server, 50, 50, 50, offset, new Vector3(0.1f, 0.1f, 0.1f)); Console.Write(string.Format("\rFrame {0}: {1} connection(s) ", dt, server.ConnectionCount)); // Work out how long to sleep for. sleepTimer.Stop(); updateElapsedMs = (int)sleepTimer.ElapsedMilliseconds; if (updateElapsedMs + 1 < targetFrameTimeMs) { // Sleep until the next frame. Sleep for a millisecond less than we need to allow // a bit of overhead. System.Threading.Thread.Sleep(targetFrameTimeMs - (updateElapsedMs + 1)); } } server.UpdateFrame(0); server.ConnectionMonitor.Stop(); server.ConnectionMonitor.Join(); }
/// <summary> /// Handles an unconnected message, usually from the auth server. /// </summary> private void HandleUnconnectedMessage(NetIncomingMessage im) { if (im == null) { throw new ArgumentNullException(nameof(im)); } // Make sure the unconnected message is coming from the real auth server. if (Equals(im.SenderEndPoint, networkManager.AuthEndpoint) && im.SenderEndPoint.Port == Globals.Values.DefaultAuthPort) { var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent switch (messageType) { case MessageTypes.AuthInit: { var msg = new AuthInitMessage(im, MessageContext.Client); networkManager.Client.Events.Network.Auth.InitReceived.Invoke( new EventManager.NetEvents.AuthServerEvents.InitEventArgs(msg.Username, msg.UUID, msg.PrivateKey, msg.PublicKey)); break; } case MessageTypes.FailedLogin: { var msg = new FailedLoginMessage(im, MessageContext.Client); networkManager.Client.Events.Network.Auth.FailedLogin.Invoke( new EventManager.NetEvents.AuthServerEvents.FailedLoginEventArgs(msg.ErrorMessage)); break; } case MessageTypes.Verified: { var msg = new VerifiedMessage(im, MessageContext.Client); networkManager.Client.Events.Network.Auth.Verified.Invoke( new EventManager.NetEvents.AuthServerEvents.VerifiedEventArgs(msg.Verified)); break; } case MessageTypes.PluginDownload: { var msg = new PluginDownloadMessage(im, MessageContext.Client); networkManager.Client.Events.Network.Auth.PluginDownloadRequested.Invoke( new EventManager.NetEvents.AuthServerEvents.PluginDownloadEventArgs(msg)); break; } } } else // Message not from auth server, instead from a game server { var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent switch (messageType) { case MessageTypes.ServerInfo: { var msg = new ServerInfoMessage(im, MessageContext.Client); networkManager.Client.Events.Network.Game.ServerInfoReceived.Invoke( new EventManager.NetEvents.GameServerEvents.ServerInfoEventArgs(msg.Description, msg.Players, msg.MaxPlayers, im.SenderEndPoint)); break; } } } }
static void Main(string[] args) { if (HaveOption("help", args)) { ShowUsage(); return; } Console.CancelKeyPress += new ConsoleCancelEventHandler(ControlCHandler); ServerSettings serverSettings = ServerSettings.Default; serverSettings.PortRange = 10; ServerInfoMessage info = ServerInfoMessage.Default; info.CoordinateFrame = CoordinateFrame.XYZ; if (HaveOption("compress", args)) { serverSettings.Flags |= ServerFlag.Compress; } IServer server = new TcpServer(serverSettings, info); List <Shapes.Shape> shapes = new List <Shapes.Shape>(); List <ShapeMover> movers = new List <ShapeMover>(); List <Resource> resources = new List <Resource>(); Ids ids = new Ids(); ids.NextShapeId = 1; CreateAxes(ids, shapes, movers, resources, args); CreateShapes(ids, shapes, movers, resources, args); const int targetFrameTimeMs = 1000 / 30; int updateElapsedMs = 0; float dt = 0; float time = 0; Stopwatch frameTimer = new Stopwatch(); Stopwatch sleepTimer = new Stopwatch(); // Register shapes with server. foreach (Shapes.Shape shape in shapes) { server.Create(shape); } if (!server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous)) { Console.WriteLine("Failed to start listen socket."); return; } Console.WriteLine(string.Format("Listening on port {0}", server.ConnectionMonitor.Port)); frameTimer.Start(); while (!Quit) { frameTimer.Stop(); dt = frameTimer.ElapsedMilliseconds * 1e-3f; time += dt; frameTimer.Reset(); frameTimer.Start(); sleepTimer.Reset(); sleepTimer.Start(); foreach (ShapeMover mover in movers) { mover.Update(time, dt); server.Update(mover.Shape); } server.UpdateFrame(dt); if (server.ConnectionMonitor.Mode == ConnectionMonitorMode.Synchronous) { server.ConnectionMonitor.MonitorConnections(); } server.ConnectionMonitor.CommitConnections((IServer s, IConnection connection) => { foreach (Shapes.Shape shape in shapes) { connection.Create(shape); } }); server.UpdateTransfers(64 * 1024); Console.Write(string.Format("\rFrame {0}: {1} connection(s) ", dt, server.ConnectionCount)); // Console Flush? // Work out how long to sleep for. sleepTimer.Stop(); updateElapsedMs = (int)sleepTimer.ElapsedMilliseconds; if (updateElapsedMs + 1 < targetFrameTimeMs) { // Sleep until the next frame. Sleep for a millisecond less than we need to allow // a bit of overhead. System.Threading.Thread.Sleep(targetFrameTimeMs - (updateElapsedMs + 1)); } } foreach (Shapes.Shape shape in shapes) { server.Destroy(shape); } server.UpdateFrame(0); server.ConnectionMonitor.Stop(); server.ConnectionMonitor.Join(); }
static void ValidateClient(TcpClient socket, Shape reference, ServerInfoMessage serverInfo, CreateShapeFunction createShape, ShapeValidationFunction validate, uint timeoutSec = 10u) { Stopwatch timer = new Stopwatch(); ServerInfoMessage readServerInfo = new ServerInfoMessage(); Dictionary <ulong, Resource> resources = new Dictionary <ulong, Resource>(); PacketBuffer packetBuffer = new PacketBuffer(64 * 1024); Shape shape = createShape(); bool endMsgReceived = false; bool serverInfoRead = false; bool shapeMsgRead = false; timer.Start(); // Keep looping until we get a CIdEnd ControlMessage or timeoutSec elapses. // Timeout ignored when debugger is attached. while (!endMsgReceived && (Debugger.IsAttached || timer.ElapsedMilliseconds / 1000u < timeoutSec)) { if (socket.Available <= 0) { Thread.Yield(); continue; } // Data available. Read from the network stream into a buffer and attempt to // read a valid message. packetBuffer.Append(socket.GetStream(), socket.Available); PacketBuffer completedPacket; bool crcOk = true; while ((completedPacket = packetBuffer.PopPacket(out crcOk)) != null || !crcOk) { Assert.True(crcOk); if (crcOk) { if (packetBuffer.DroppedByteCount != 0) { Console.Error.WriteLine("Dropped {0} bad bytes", packetBuffer.DroppedByteCount); packetBuffer.DroppedByteCount = 0; } Assert.Equal(PacketHeader.PacketMarker, completedPacket.Header.Marker); Assert.Equal(PacketHeader.PacketVersionMajor, completedPacket.Header.VersionMajor); Assert.Equal(PacketHeader.PacketVersionMinor, completedPacket.Header.VersionMinor); NetworkReader packetReader = new NetworkReader(completedPacket.CreateReadStream(true)); switch (completedPacket.Header.RoutingID) { case (int)RoutingID.ServerInfo: serverInfoRead = true; Assert.True(readServerInfo.Read(packetReader)); // Validate server info. Assert.Equal(serverInfo.TimeUnit, readServerInfo.TimeUnit); Assert.Equal(serverInfo.DefaultFrameTime, readServerInfo.DefaultFrameTime); Assert.Equal(serverInfo.CoordinateFrame, readServerInfo.CoordinateFrame); unsafe { for (int i = 0; i < ServerInfoMessage.ReservedBytes; ++i) { Assert.Equal(serverInfo.Reserved[i], readServerInfo.Reserved[i]); } } break; case (int)RoutingID.Control: { // Only interested in the CIdEnd message to mark the end of the stream. ControlMessage msg = new ControlMessage(); Assert.True(msg.Read(packetReader)); if (completedPacket.Header.MessageID == (int)ControlMessageID.End) { endMsgReceived = true; } break; } case (int)RoutingID.Mesh: HandleMeshMessage(completedPacket, packetReader, resources); break; default: if (completedPacket.Header.RoutingID == reference.RoutingID) { shapeMsgRead = true; HandleShapeMessage(completedPacket, packetReader, shape, reference); } break; } } } // else fail? } Assert.True(serverInfoRead); Assert.True(shapeMsgRead); Assert.True(endMsgReceived); // Validate the shape state. if (shapeMsgRead) { validate(shape, reference, resources); } }
/// <summary> /// The process network messages such as users joining, moving, etc /// </summary> public void ProcessNetworkMessages() { while (NetManager.NetServer.Status == NetPeerStatus.Running) { // If an issue occurs with this (again), see the discussion at: // https://groups.google.com/forum/#!topic/lidgren-network-gen3/EN3vaykwBWM NetManager.NetServer.MessageReceivedEvent.WaitOne(); try { NetIncomingMessage inc; // Used to store messages while ((inc = NetManager.ReadMessage()) != null) { switch (inc.MessageType) { case NetIncomingMessageType.Error: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.WarningMessage: Logger.WriteLine(LogType.Error, "MessageHandler Loop: " + inc.ReadString()); break; // ConnectionApproval messages are sent when a client would like to connect to the server case NetIncomingMessageType.ConnectionApproval: { // If client does not send username information (Purposely trying to use a modded client?) if (inc.LengthBytes == 0) { inc.SenderConnection?.Deny("Invalid Hail Message"); break; } var type = (MessageTypes)Enum.Parse(typeof(MessageTypes), inc.ReadByte().ToString()); // Find message type switch (type) { // The connection should come with a public key to verify the client's session case MessageTypes.PublicKey: { var msg = new PublicKeyMessage(inc, MessageContext.Client); Server.Events.Network.UserLoginRequested.Invoke( new EventManager.NetEvents.LoginRequestEventArgs(msg.Username, msg.UUID, msg.PublicKey, inc.SenderConnection)); break; } } break; } // Data messages are all messages manually sent from client // These are the bulk of the messages, used for Sender movement, block placing, etc case NetIncomingMessageType.Data: { ProcessDataMessage(inc); break; } // StatusChanged messages occur when a client connects, disconnects, is approved, etc // NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with Disconnect() case NetIncomingMessageType.StatusChanged: { var sender = Server.PlayerFromRUI(inc.SenderConnection.RemoteUniqueIdentifier, true); // When a player's connection is finalized if (inc.SenderConnection != null && inc.SenderConnection.Status == NetConnectionStatus.Connected) { if (sender != null) { Server.Events.Network.UserConnected.Invoke( new EventManager.NetEvents.ConnectionEventArgs(sender)); } } // When a client disconnects else if (inc.SenderConnection != null && (inc.SenderConnection.Status == NetConnectionStatus.Disconnected || inc.SenderConnection.Status == NetConnectionStatus.Disconnecting)) { if (sender != null) { Server.Events.Network.UserDisconnected.Invoke( new EventManager.NetEvents.DisconnectionEventArgs(sender, inc.ReadString())); } } break; } // Listen to unconnected data case NetIncomingMessageType.UnconnectedData: { var type = (MessageTypes)Enum.Parse(typeof(MessageTypes), inc.ReadByte().ToString()); // Handle messages from the auth server differently then ones from players (ping requests) if (Equals(inc.SenderEndPoint, NetManager.AuthEndpoint)) { switch (type) { // When the auth server confirms if a session is valid or not. case MessageTypes.ValidSession: { var msg = new ValidSessionMessage(inc, MessageContext.Server); Server.Events.Network.SessionValidated.Invoke( new EventManager.NetEvents.SessionEventArgs( msg.Username, msg.UUID, msg.Valid)); break; } } } else { switch (type) { // When the auth server confirms if a session is valid or not. case MessageTypes.ServerInfo: { // ReSharper disable once UnusedVariable var msg = new ServerInfoMessage(inc, MessageContext.Server); Server.Events.Network.InfoRequested.Invoke( new EventManager.NetEvents.RequestInfoEventArgs( inc.SenderEndPoint)); break; } } } break; } } NetManager.Recycle(inc); } } catch (Exception e) { Logger.WriteLine(LogType.Error, e.ToString()); } } }
/// <summary> ///This function do the following things ///-increment the NextClientId ///-Assign Profile.ClientId=i /// Attaches the client. /// /// /// Fetches the URI of the remote host that sent a request. /// </summary> /// <param name="nickname">Nickname.</param> public int AttachClient(string nickname, ClientProfile profile, MessageObject msg) { try { int id=NextClientId++; profile.ClientId=id; /* * this.restartTimer = true; *is commented because its not using anywhere in the code. */ //this.restartTimer = true; showFailReciverList("public int AttachClient(string nickname, ClientProfile profile, MessageObject msg)"); // change relevant to close meeting. // if(conferenceCloseThread.ThreadState == System.Threading.ThreadState.Running) // this.conferenceCloseThread.Suspend(); bHostJoined =(profile.clientType == ClientType.ClientHost); strMeetingId=profile.ConferenceID.ToString(); string receiverUri = GenuineUtility.FetchCurrentRemoteUri() + "/MessageReceiver.rem"; IMessageReceiver iMessageReceiver = (IMessageReceiver) Activator.GetObject(typeof(IMessageReceiver), receiverUri); profile.clientURI=receiverUri; GenuineUtility.CurrentSession["ConnectionID"] = id; // Console.WriteLine("Client with nickname \"{0}\" has been registered{1}.", nickname,NextClientId); while(m_bLocked==true) { Console.WriteLine("Meeting jammed in while loop in attachclient()line 1710 & meetingID->" + strMeetingId + " Participant Name ->"+profile.Name ); System.Threading.Thread.Sleep(1000); } m_bLocked=true; this._dispatcher.Add((MarshalByRefObject) iMessageReceiver); this.ClientList.Add(profile.ClientId,profile); m_bLocked=false; iMessageReceiver.ReceiveMessage(msg);// sending the authentication message /* * When host is joined, its color should be Red. * colorsArray[0] is red color */ if(profile.clientType==ClientType.ClientHost) { profile.m_AssignedColor = colorsArray[0]; } else { if(mcount==0)//checking index for assigning attendee { //if 0 index then increment it profile.m_AssignedColor = colorsArray[mcount+1]; } else //Simple Assign index because assinging will not { //be red color profile.m_AssignedColor = colorsArray[mcount]; } } SendUserJoinMessage(profile); mcount++; if(mcount >= 15) mcount = 0; //Send all profile Lists to joing participant. ServerInfoMessage infoMsg = new ServerInfoMessage(); infoMsg.SenderID=-1; infoMsg.AttendeeProfileList = ClientList; iMessageReceiver.ReceiveMessage(infoMsg); // senfing the info message // It should be removed SendConferenceParameters(iMessageReceiver); return id; } catch(Exception ex) { m_bLocked=false; Console.WriteLine("Exception Message Occured at AttachClient-> "+ex.Message.ToString()+" Exception source :::"+ex.StackTrace+" Exception StackTrace ::: "+ex.StackTrace+" Exception Tostring ::: "+ex.ToString()); m_bLocked=false; return 0; } }
/// <summary> /// Create a new <see cref="TcpServer"/> with the given <paramref name="settings"/> /// and <paramref name="serverInfo"/>. /// </summary> /// <param name="settings">The settings to instantiate with.</param> /// <param name="serverInfo">The <see cref="ServerInfoMessage"/> sent to new clients.</param> public TcpServer(ServerSettings settings, ServerInfoMessage serverInfo) { Settings = settings; ServerInfo = serverInfo; ConnectionMonitor = new ConnectionMonitor(this); }