public override SocketTasks StartClient() { SocketConfig config = GetConfig(false, NetworkingManager.Singleton.NetworkConfig); socket = new RuffleSocket(config); isConnector = true; if (!socket.Start()) { return(SocketTask.Fault.AsTasks()); } serverConnection = socket.Connect(new IPEndPoint(IPAddress.Parse(ConnectAddress), Port)); if (serverConnection == null) { return(SocketTask.Fault.AsTasks()); } else { connectTask = SocketTask.Working; return(connectTask.AsTasks()); } }
public bool Connect(IPEndPoint endPoint) { socket = new RuffleSocket(new SocketConfig { ChallengeDifficulty = 20, ChannelTypes = new[] { ChannelType.ReliableSequencedFragmented }, DualListenPort = 0 }); if (!socket.Start()) { return(false); } var con = socket.Connect(endPoint); if (con != null) { return(true); } return(false); }
public static void Server() { RuffleSocket socket = new RuffleSocket(new Configuration.SocketConfig() { AllowBroadcasts = true, AllowUnconnectedMessages = true, DualListenPort = 5555 }); socket.Start(); while (true) { // Wait for message. This is to prevent a tight loop socket.SyncronizationEvent.WaitOne(1000); NetworkEvent @event; while ((@event = socket.Poll()).Type != NetworkEventType.Nothing) { if (@event.Type == NetworkEventType.BroadcastData) { // We got a broadcast. Reply to them with the same token they used socket.SendUnconnected(@event.Data, (IPEndPoint)@event.EndPoint); } // Recycle the event @event.Recycle(); } } }
public override void StartServer() { SocketConfig config = GetConfig(); config.DualListenPort = (ushort)ServerListenPort; socket = new RuffleSocket(config); }
public override SocketTasks StartServer() { SocketConfig config = GetConfig(); config.DualListenPort = (ushort)ServerListenPort; socket = new RuffleSocket(config); return(SocketTask.Done.AsTasks()); }
internal Connection(ulong id, ConnectionState state, IPEndPoint endpoint, RuffleSocket socket) { #if ALLOW_CONNECTION_STUB if (IsStub) { // NOOP return; } #endif this.Id = id; this.Socket = socket; this.EndPoint = endpoint; this.MTU = Config.MinimumMTU; this.SmoothRoundtrip = 0; this.HighestRoundtripVarience = 0; this.Roundtrip = 500; this.LowestRoundtrip = 500; this.LastMessageIn = NetTime.Now; this.LastMessageOut = NetTime.Now; this.ConnectionStarted = NetTime.Now; this.ConnectionCompleted = NetTime.Now; this.HandshakeStarted = NetTime.Now; this.HandshakeLastSendTime = NetTime.Now; this.HandshakeResendAttempts = 0; this.ChallengeAnswer = 0; this.ConnectionChallenge = RandomProvider.GetRandomULong(); this.ChallengeDifficulty = (byte)Config.ChallengeDifficulty; this.PreConnectionChallengeTimestamp = 0; this.PreConnectionChallengeCounter = 0; this.PreConnectionChallengeIV = 0; this.PreConnectionChallengeSolved = false; this.State = state; if (Config.EnableBandwidthTracking && Config.CreateBandwidthTracker != null) { this.BandwidthTracker = Config.CreateBandwidthTracker(); } if (Config.EnableHeartbeats) { this.HeartbeatChannel = new UnreliableOrderedChannel(0, this, Config, MemoryManager); } if (Config.EnablePacketMerging) { this.Merger = new MessageMerger(Config.MaxMergeMessageSize, Config.MinimumMTU); } if (Logging.CurrentLogLevel <= LogLevel.Debug) { Logging.LogInfo("Allocating " + Config.EventQueueSize + " event slots"); } this._userEventQueue = new ConcurrentCircularQueue <NetworkEvent>(Config.EventQueueSize, true); this.IsUserEventQueueActive = true; }
internal ReliableSequencedChannel(byte channelId, Connection connection, RuffleSocket socket, SocketConfig config) { this.channelId = channelId; this.connection = connection; this.socket = socket; this.config = config; // Alloc the in flight windows for receive and send _receiveSequencer = new HeapableSlidingWindow <PendingIncomingPacket>(config.ReliabilityWindowSize, true, sizeof(ushort)); _sendSequencer = new HeapableSlidingWindow <PendingOutgoingPacket>(config.ReliabilityWindowSize, true, sizeof(ushort)); }
public override void StartClient() { SocketConfig config = GetConfig(); // The OS will grab a port config.DualListenPort = 0; socket = new RuffleSocket(config); isConnector = true; socket.Connect(new IPEndPoint(IPAddress.Parse(ConnectAddress), ConnectPort)); }
public override bool StartServer() { SocketConfig config = GetConfig(true); socket = new RuffleSocket(config); serverConnection = null; isConnector = false; return(socket.Start()); }
public Task Run() { _server = new RuffleSocket(_serverConfig); _server.Start(); return(Task.Factory.StartNew(() => { while (true) { Update(); } }, TaskCreationOptions.LongRunning)); }
public Client(Scene scene, List<ISystem<ClientSystemUpdate>> clientSystems, Dictionary<int, Action<MemoryStream, World>> recievers, Dictionary<Type, Action<object, MemoryStream>> serializers) : base(scene, recievers, serializers) { _clientSystems = clientSystems; _camerasSet = scene.World.GetEntities().With<Transform>().With<Camera>().AsSet(); _editorMenu = new EditorMenu(); _editorMenu.Editors.Add(new ConstructEditor(scene.World)); _editorMenu.Editors.Add(new InfoViewer()); _client = new RuffleSocket(_clientConfig); _messageTimer = new Stopwatch(); }
internal Connection(ulong id, ConnectionState state, IPEndPoint endpoint, RuffleSocket socket) { #if ALLOW_CONNECTION_STUB if (IsStub) { // NOOP return; } #endif this.Id = id; this.Socket = socket; this.EndPoint = endpoint; this.MTU = Config.MinimumMTU; this.SmoothRoundtrip = 0; this.HighestRoundtripVarience = 0; this.Roundtrip = 500; this.LowestRoundtrip = 500; this.LastMessageIn = NetTime.Now; this.LastMessageOut = NetTime.Now; this.ConnectionStarted = NetTime.Now; this.ConnectionCompleted = NetTime.Now; this.HandshakeStarted = NetTime.Now; this.HandshakeLastSendTime = NetTime.Now; this.HandshakeResendAttempts = 0; this.ChallengeAnswer = 0; this.ConnectionChallenge = RandomProvider.GetRandomULong(); this.ChallengeDifficulty = (byte)Config.ChallengeDifficulty; this.PreConnectionChallengeTimestamp = 0; this.PreConnectionChallengeCounter = 0; this.PreConnectionChallengeIV = 0; this.PreConnectionChallengeSolved = false; this.State = state; if (Config.EnableBandwidthTracking && Config.CreateBandwidthTracker != null) { this.BandwidthTracker = Config.CreateBandwidthTracker(); } if (Config.EnableHeartbeats) { this.HeartbeatChannel = new UnreliableOrderedChannel(0, this, Config, MemoryManager); } if (Config.EnablePacketMerging) { this.Merger = new MessageMerger(Config.MaxMergeMessageSize, Config.MinimumMTU, Config.MaxMergeDelay); } }
/// <summary> /// Binds the UDP socket to the specified local endpoint. /// </summary> /// <param name="endpoint">The local endpoint to bind to.</param> public void Bind(IPEndPoint endpoint) { if (socket != null) { return; } // Setup the socket info here socket = new RuffleSocket(new SocketConfig() { AllowBroadcasts = true, //necessary ? AllowUnconnectedMessages = true, //necessary ? DualListenPort = endpoint.Port, IPv4ListenAddress = endpoint.Address }); socket.Start(); }
public override SocketTasks StartServer() { SocketConfig config = GetConfig(true, NetworkingManager.Singleton.NetworkConfig); socket = new RuffleSocket(config); serverConnection = null; isConnector = false; if (socket.Start()) { return(SocketTask.Done.AsTasks()); } else { return(SocketTask.Fault.AsTasks()); } }
public bool Listen(int port) { socket = new RuffleSocket(new SocketConfig { ChallengeDifficulty = 20, IPv4ListenAddress = IPAddress.Parse("0.0.0.0"), ChannelTypes = new[] { ChannelType.ReliableSequencedFragmented }, DualListenPort = port, }); var r = socket.Start(); m_Address = new RuffleTransportAddress { EndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port) }; return(r); }
public override void Shutdown() { channelNameToId.Clear(); connections.Clear(); // Release to GC messageBuffer = null; if (socket != null && socket.IsInitialized) { // Releases memory and other things socket.Shutdown(); } // Release to GC socket = null; // Release server connection to GC serverConnection = null; }
public override bool StartClient() { SocketConfig config = GetConfig(false); socket = new RuffleSocket(config); isConnector = true; if (!socket.Start()) { return(false); } serverConnection = socket.Connect(new IPEndPoint(IPAddress.Parse(ConnectAddress), Port)); if (serverConnection == null) { return(false); } return(true); }
/// <summary> /// Adds a local socket to the manager. /// </summary> /// <returns>The local socket.</returns> /// <param name="config">The socket configuration.</param> public RuffleSocket AddSocket(SocketConfig config) { if (!IsRunning) { throw new InvalidOperationException("Manager is not started"); } RuffleSocket socket = new RuffleSocket(config); if (IsThreaded) { lock (ThreadLock) { _sockets.Add(socket); } } else { _sockets.Add(socket); } return(socket); }
public override void Start(object config) { RufflesConfig rufflesConfig = null; if (config is RufflesConfig) { rufflesConfig = (RufflesConfig)config; } else if (config is JObject) { rufflesConfig = ((JObject)config).ToObject <RufflesConfig>(); } rufflesConfig.SocketConfig.DualListenPort = Program.Config.ListenPort; ChannelType[] channelTypes = rufflesConfig.SocketConfig.ChannelTypes; ChannelType[] newChannelTypes = new ChannelType[channelTypes.Length + 1]; // Copy old channels for (int i = 0; i < channelTypes.Length; i++) { newChannelTypes[i] = channelTypes[i]; } // Set the default channel newChannelTypes[newChannelTypes.Length - 1] = rufflesConfig.DefaultChannelType; // Set the default channel byte Program.DEFAULT_CHANNEL_BYTE = (byte)(newChannelTypes.Length - 1); // Change to the new array rufflesConfig.SocketConfig.ChannelTypes = newChannelTypes; // Start the socket socket = new RuffleSocket((SocketConfig)config); }
private static void NoRufflesManager() { RuffleSocket server = new RuffleSocket(ServerConfig); RuffleSocket client = new RuffleSocket(ClientConfig); // IPv4 Connect //client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5674)); // IPv6 Connect client.Connect(new IPEndPoint(IPAddress.Parse("0:0:0:0:0:0:0:1"), 5674)); // The server stores the clients id here ulong clientId = 0; // The client stores the servers id here ulong serverId = 0; // The time when the connection started DateTime started = DateTime.Now; // The time when the last message was sent DateTime lastSent = DateTime.MinValue; // The amount of message that has been received int messagesReceived = 0; // The amount of messages that has been sent int messageCounter = 0; while (true) { // Runs all the internals client.RunInternalLoop(); // Runs all the internals server.RunInternalLoop(); // Polls server for events NetworkEvent serverEvent = server.Poll(); // Polls client for events NetworkEvent clientEvent = client.Poll(); if (serverEvent.Type != NetworkEventType.Nothing) { if (serverEvent.Type != NetworkEventType.Data) { Console.WriteLine("ServerEvent: " + serverEvent.Type); } if (serverEvent.Type == NetworkEventType.Connect) { clientId = serverEvent.Connection.Id; } if (serverEvent.Type == NetworkEventType.Disconnect || serverEvent.Type == NetworkEventType.Timeout) { serverEvent.Connection.Recycle(); } } if (clientEvent.Type != NetworkEventType.Nothing) { if (clientEvent.Type != NetworkEventType.Data) { Console.WriteLine("ClientEvent: " + clientEvent.Type); } if (clientEvent.Type == NetworkEventType.Connect) { serverId = clientEvent.Connection.Id; } if (clientEvent.Type == NetworkEventType.Data) { messagesReceived++; Console.WriteLine("Got message: \"" + Encoding.ASCII.GetString(clientEvent.Data.Array, clientEvent.Data.Offset, clientEvent.Data.Count) + "\""); clientEvent.Recycle(); } if (clientEvent.Type == NetworkEventType.Disconnect || clientEvent.Type == NetworkEventType.Timeout) { clientEvent.Connection.Recycle(); } } if ((DateTime.Now - started).TotalSeconds > 10 && (DateTime.Now - lastSent).TotalSeconds >= 1) { byte[] helloReliable = Encoding.ASCII.GetBytes("This message was sent over a reliable channel" + messageCounter); byte[] helloReliableSequenced = Encoding.ASCII.GetBytes("This message was sent over a reliable sequenced channel" + messageCounter); server.Send(new ArraySegment <byte>(helloReliableSequenced, 0, helloReliableSequenced.Length), clientId, 0, false); server.Send(new ArraySegment <byte>(helloReliable, 0, helloReliable.Length), clientId, 1, false); messageCounter++; lastSent = DateTime.Now; } } }
public static void Client() { RuffleSocket socket = new RuffleSocket(new Configuration.SocketConfig() { AllowBroadcasts = true, AllowUnconnectedMessages = true, DualListenPort = 0 }); socket.Start(); // Wait for message. This is to prevent a tight loop socket.SyncronizationEvent.WaitOne(1000); // Create RNG System.Random rnd = new System.Random(); // Alloc token byte[] token = new byte[32]; // Fill buffer with random data rnd.NextBytes(token); // Save last send time DateTime lastBroadcastSendTime = DateTime.MinValue; while (true) { // If we havent sent broadcast for 5 seconds if ((DateTime.Now - lastBroadcastSendTime).TotalSeconds > 5) { lastBroadcastSendTime = DateTime.Now; // Send broadcast socket.SendBroadcast(new ArraySegment <byte>(token), 5555); } // Wait for message. This is to prevent a tight loop socket.SyncronizationEvent.WaitOne(1000); NetworkEvent @event; while ((@event = socket.Poll()).Type != NetworkEventType.Nothing) { if (@event.Type == NetworkEventType.UnconnectedData) { // We got a reply. Ensure the token is correct if (@event.Data.Count == token.Length) { bool missMatch = false; // The token had the same length. Check all elements for (int i = 0; i < @event.Data.Count; i++) { if (@event.Data.Array[@event.Data.Offset + i] != token[i]) { // This element did not match. Exit missMatch = true; break; } } if (missMatch) { // Continue the receive loop the loop continue; } else { // All matched. Console.WriteLine("Found server at endpoint: " + ((IPEndPoint)@event.EndPoint)); } } } // Recycle the event @event.Recycle(); } } }
static void Main(string[] args) { //Get Ruffles socket from MLAPI RuffleSocket socket = new RuffleSocket(new SocketConfig() { AllowBroadcasts = true, //necessary ? AllowUnconnectedMessages = true, //necessary ? }); IUDPTransport rufflesTransport = new MLAPI.Puncher.Shared.RufflesUDPTransport(socket); Task listenTask = Task.Factory.StartNew(() => { try { using (PuncherClient listenPeer = new PuncherClient(PUNCHER_SERVER_HOST, PUNCHER_SERVER_PORT) { Transport = rufflesTransport }) { System.Console.WriteLine("[LISTENER] Listening for single punch on our port 1234..."); IPEndPoint endpoint = listenPeer.ListenForSinglePunch(new IPEndPoint(IPAddress.Any, 1234)); System.Console.WriteLine("[LISTENER] Connector: " + endpoint + " punched through our NAT"); } } catch (Exception e) { System.Console.WriteLine(e); } }); // Wait a bit to make sure the listener has a chance to register. Thread.Sleep(1000); System.Console.Write("[CONNECTOR] Enter the address of the listener you want to punch: "); string address = System.Console.ReadLine(); using (PuncherClient connectPeer = new PuncherClient(PUNCHER_SERVER_HOST, PUNCHER_SERVER_PORT) { Transport = rufflesTransport }) { System.Console.WriteLine("[CONNECTOR] Punching..."); if (connectPeer.TryPunch(IPAddress.Parse(address), out IPEndPoint connectResult)) { System.Console.WriteLine("[CONNECTOR] Punched through to peer: " + connectResult); } else { System.Console.WriteLine("[CONNECTOR] Failed to punch"); } // Prevent application from exiting before listener has ended listenTask.Wait(); } // For the plebs System.Console.Read(); }
public RufflesUDPTransport(RuffleSocket rsock) { socket = rsock; }
public static void Main(string[] args) { RuffleSocket server = new RuffleSocket(ServerConfig); RuffleSocket client = new RuffleSocket(ClientConfig); client.Start(); server.Start(); if (IPv6) { // IPv6 Connect client.Connect(new IPEndPoint(IPAddress.Parse("0:0:0:0:0:0:0:1"), 5674)); } else { // IPv4 Connect client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5674)); } // The server stores the clients id here Connection clientConnection = null; // The client stores the servers id here Connection serverConnection = null; // The time when the connection started DateTime started = DateTime.Now; // The time when the last message was sent DateTime lastSent = DateTime.MinValue; // The time the last status was printed DateTime lastStatusPrint = DateTime.MinValue; // The amount of message that has been received int messagesReceived = 0; // The amount of messages that has been sent int messageCounter = 0; while (true) { // Polls server for events NetworkEvent serverEvent = server.Poll(); // Polls client for events NetworkEvent clientEvent = client.Poll(); if (serverEvent.Type != NetworkEventType.Nothing) { Console.WriteLine("ServerEvent: " + serverEvent.Type); if (serverEvent.Type == NetworkEventType.Connect) { clientConnection = serverEvent.Connection; } if (serverEvent.Type == NetworkEventType.AckNotification) { Console.WriteLine("The remote acked message id: " + serverEvent.NotificationKey); } } serverEvent.Recycle(); if (clientEvent.Type != NetworkEventType.Nothing) { Console.WriteLine("ClientEvent: " + clientEvent.Type); if (clientEvent.Type == NetworkEventType.Connect) { serverConnection = clientEvent.Connection; } if (clientEvent.Type == NetworkEventType.Data) { messagesReceived++; Console.WriteLine("Got message: \"" + Encoding.ASCII.GetString(clientEvent.Data.Array, clientEvent.Data.Offset, clientEvent.Data.Count) + "\""); } } clientEvent.Recycle(); if (serverConnection != null && clientConnection != null && serverConnection.State == ConnectionState.Connected && clientConnection.State == ConnectionState.Connected && (DateTime.Now - lastSent).TotalSeconds >= (1f / 1)) { byte[] helloReliable = Encoding.ASCII.GetBytes("This message was sent over a reliable channel" + messageCounter); clientConnection.Send(new ArraySegment <byte>(helloReliable, 0, helloReliable.Length), 1, false, (ulong)messageCounter); Console.WriteLine("Sending packet: " + messageCounter); messageCounter++; lastSent = DateTime.Now; } if (serverConnection != null && clientConnection != null && serverConnection.State == ConnectionState.Connected && clientConnection.State == ConnectionState.Connected && (DateTime.Now - lastStatusPrint).TotalSeconds >= 5) { Console.WriteLine("Ping: " + serverConnection.SmoothRoundtrip + "ms, " + clientConnection.SmoothRoundtrip + "ms"); lastStatusPrint = DateTime.Now; } } }