Beispiel #1
0
 public Host(int port)
 {
     EnableHandshake = true;
     AllowedTokens   = AllowedTokens.Any;
     //ValidateMessageTypes();
     _listenThread      = new Thread(() => Listen(port));
     _port              = port;
     _isListening       = false;
     _connectionManager = new ConnectionManager();
     _receiveHandlers   = new Dictionary <short, IList <ReceiveHandler> >();
     Rnd = new Random();
     AddHandler((short)MessageType.Token, (m, c) => {
         _hostToken = m.ConnectionToken;
         if (OnConnect != null)
         {
             OnConnect.Invoke();
         }
     });
     AddHandler((short)MessageType.Handshake, (m, c) => {
         if (!EnableHandshake)
         {
             return;
         }
         if (ConnectionCreated != null)
         {
             ConnectionCreated.Invoke(c);
         }
         SendToken(c);
     });
     AddHandler((short)MessageType.Ack, (m, c) => { c.ProcessAck(m); });
     ServerTimer.OnTick += ServerTick;
 }
Beispiel #2
0
        public Host(int port)
        {
            EnableHandshake = true;
            AllowedTokens   = AllowedTokens.Any;
            //ValidateMessageTypes();
            _listenThread      = new Thread(() => Listen(port));
            _isListening       = false;
            _connectionManager = new ConnectionManager();
            _receiveHandlers   = new Dictionary <short, IList <ReceiveHandler> >();
            AddHandler((short)MessageType.Token, (m, c) =>
            {
                _hostToken = m.ConnectionToken;
                if (OnConnect != null)
                {
                    OnConnect.Invoke();
                }
            });
            AddHandler((short)MessageType.Handshake, (m, c) =>
            {
                if (!EnableHandshake)
                {
                    return;
                }
                if (ConnectionCreated != null)
                {
                    ConnectionCreated.Invoke(c);
                }
                SendToken(c);
            });
            AddHandler((short)MessageType.Ack, (m, c) => { c.ProcessAck(m); });
            ServerTimer.OnTick += ServerTick;
            AddHandler((short)MessageType.Resend, (m, c) =>
            {
                var mode    = (m.Ordered ? Mode.Ordered : Mode.None) & (m.Reliable ? Mode.Reliable : Mode.None) & (m.Sequenced ? Mode.Sequenced : Mode.None);
                var message = new Message((short)MessageType.SendToEndPoint, mode, m.Body);
                foreach (var connection in GetConnections())
                {
                    if (c != connection)
                    {
                        Send(message, connection);
                    }
                }
            });
            AddHandler((short)MessageType.SendToEndPoint, (m, c) =>
            {
                var ds         = DataStorage.CreateForRead(m.Body);
                var methodName = ds.ReadString();

                NetworkController.Instance.RPCMessage(methodName, ds);
            });
        }
Beispiel #3
0
        public IDbConnection CreateConnection()
        {
            if (_sharedConnection != null)
            {
                return(_sharedConnection);
            }
            var connection = _connectionModifier(_connectionProvider.CreateConnection());
            var args       = ConnectionCreated.Raise(this, () => new ConnectionCreatedEventArgs(connection));

            if (args != null && args.OverriddenConnection != null)
            {
                return(args.OverriddenConnection);
            }
            return(connection);
        }
Beispiel #4
0
        void DoAcceptTcpClientCallback(IAsyncResult ar)
        {
            if (!ar.IsCompleted)
            {
                return;
            }
            bool docontinue = true;

            var listener = (Socket)ar.AsyncState;

            try
            {
                var socket = listener.EndAccept(ar);

                var ntcpc = new NTCPClientIncoming(socket);
                Logging.LogTransport($"NTCPHost: incoming connection {ntcpc.DebugId} from " +
                                     $"{socket.RemoteEndPoint} created.");

                ConnectionCreated?.Invoke(ntcpc);

                ntcpc.Connect();
                lock ( Clients )
                {
                    Clients.Add(ntcpc);
                }
            }
            catch (ObjectDisposedException)
            {
                docontinue = false;
            }
            catch (Exception ex)
            {
                Logging.Log(ex);
            }

            try
            {
                if (docontinue)
                {
                    listener.BeginAccept(new AsyncCallback(DoAcceptTcpClientCallback), listener);
                }
            }
            catch (Exception ex)
            {
                Logging.Log(ex);
            }
        }
Beispiel #5
0
 protected virtual void OnConnectionCreated(ConnectionCreatedEventArgs e)
 {
     ConnectionCreated?.Invoke(this, e);
 }
 protected virtual void OnConnectionCreated(PBSConnection connection)
 {
     _connections = null;
     ConnectionCreated?.Invoke(connection);
 }
Beispiel #7
0
        private void ReceiveCallback(IAsyncResult ar)
        {
            SSUSession session = null;

            try
            {
                EndPoint ep   = RemoteEP;
                var      size = MySocket.EndReceiveFrom(ar, ref ep);

                if (ep.AddressFamily != AddressFamily.InterNetwork &&
                    (!SessionLayer.RouterContext.Inst.UseIpV6 ||
                     ep.AddressFamily != AddressFamily.InterNetworkV6))
                {
                    return;         // TODO: Add IPV6
                }
                if (size <= 37)
                {
                    Logging.LogDebugData($"SSU Recv: {size} bytes [0x{size:X}] from {ep} (hole punch, ignored)");
                    return;
                }

                var sessionendpoint = (IPEndPoint)ep;

                Logging.LogDebugData($"SSU Recv: {size} bytes [0x{size:X}] from {ep}");

                lock ( Sessions )
                {
                    if (!Sessions.ContainsKey(sessionendpoint))
                    {
                        if (IPFilter.IsFiltered(((IPEndPoint)ep).Address))
                        {
                            Logging.LogTransport($"SSUHost ReceiveCallback: IPAddress {sessionendpoint} is blocked. {size} bytes.");
                            return;
                        }

                        ++IncommingConnectionAttempts;

                        Logging.LogTransport($"SSUHost: incoming connection " +
                                             $"from {sessionendpoint} created.");

                        session = new SSUSession(
                            this,
                            Send,
                            (IPEndPoint)ep,
                            MyRouterContext);

                        Sessions[sessionendpoint] = session;

                        Logging.LogTransport($"SSUHost: incoming connection " +
                                             $"{session.DebugId} from {sessionendpoint} created.");

                        NeedCpu(session);
                        ConnectionCreated?.Invoke(session);
                    }
                    else
                    {
                        session = Sessions[sessionendpoint];
                    }
                }

                var localbuffer = BufRefLen.Clone(ReceiveBuf, 0, size);

#if DEBUG
                Stopwatch Stopwatch1 = new Stopwatch();
                Stopwatch1.Start();
#endif
                try
                {
                    session.Receive(localbuffer);
                }
                catch (ThreadAbortException taex)
                {
                    AddFailedSession(session);
                    Logging.Log(taex);
                }
                catch (ThreadInterruptedException tiex)
                {
                    AddFailedSession(session);
                    Logging.Log(tiex);
                }
                catch (ChecksumFailureException cfex)
                {
                    AddFailedSession(session);
                    Logging.Log(cfex);
                }
                catch (SignatureCheckFailureException scex)
                {
                    AddFailedSession(session);
                    Logging.Log(scex);
                }
                catch (FailedToConnectException fcex)
                {
                    AddFailedSession(session);
#if LOG_MUCH_TRANSPORT
                    Logging.LogTransport(fcex);
#endif
                    if (session != null)
                    {
                        NetDb.Inst.Statistics.FailedToConnect(session.RemoteRouterIdentity.IdentHash);
                        session.RaiseException(fcex);
                    }
                }
#if DEBUG
                Stopwatch1.Stop();
                if (Stopwatch1.ElapsedMilliseconds > SessionCallWarningLevelMilliseconds)
                {
                    Logging.LogTransport(
                        $"SSUHost ReceiveCallback: WARNING Session {session} used {Stopwatch1.ElapsedMilliseconds}ms cpu.");
                }
#endif
            }
            catch (Exception ex)
            {
                AddFailedSession(session);
                Logging.Log(ex);

                if (session != null && session.RemoteRouterIdentity != null && NetDb.Inst != null)
                {
                    NetDb.Inst.Statistics.DestinationInformationFaulty(session.RemoteRouterIdentity.IdentHash);
                    session.RaiseException(ex);
                }
            }
            finally
            {
                RemoteEP = LocalEP;
                MySocket.BeginReceiveFrom(ReceiveBuf, 0, ReceiveBuf.Length, SocketFlags.None, ref RemoteEP,
                                          new AsyncCallback(ReceiveCallback), MySocket);
            }
        }
Beispiel #8
0
 protected virtual void OnConnectionCreated(object sender, EventArgs e)
 {
     ConnectionCreated?.Invoke(sender, e);
 }
Beispiel #9
0
 public void OnConnectionCreated()
 {
     ConnectionCreated?.Invoke(this, new ConnectionCreatedEventArgs {
     });
 }
 internal virtual void OnConnectionCreated(RemotingDbConnection connection)
 {
     ConnectionCreated?.Invoke(connection);
 }
        private void ReceiveCallback(IAsyncResult asyncResult)
        {
            var state = asyncResult.AsyncState as BeginReceiveState;

            if (state == null)
            {
                return;
            }

            int bytesRecieved = 0;

            if (state.ListenSocket != null)
            {
                lock (_socketAccessLock)
                {
                    if (state.ListenSocket != null)
                    {
                        try
                        {
                            bytesRecieved = state.ListenSocket.EndReceiveFrom(asyncResult, ref state.RemotePeer);
                            var bufferSize = state.ListenSocket.BeginReceiveFrom(state.Data, 0, state.Data.Length,
                                                                                 SocketFlags.None,
                                                                                 ref state.RemotePeer,
                                                                                 ReceiveCallback,
                                                                                 state);
                        }
                        catch (ObjectDisposedException) // Socket has been closed.
                        {
                            if (_clientsTable.Contains(state.RemotePeer))
                            {
                                _clientsTable.Remove(state.RemotePeer);
                                var ipAddress = ((IPEndPoint)state.RemotePeer).Address;
                                CheckIfAddressIsMapped(ref ipAddress);
                                ConnectionClosed?.Invoke(ipAddress.ToString(), (ushort)((IPEndPoint)state.RemotePeer).Port);
                            }
                            return;
                        }
                        catch (SocketException ex) // An error occurred when attempting to access the socket.
                        {
                            ex.Message._DLOG();
                            CloseSocket();
                            return;
                        }
                        catch (InvalidCastException ex)
                        {
                            ex.Message._DLOG();
                        }
                    }
                }
            }

            if (bytesRecieved > 0)
            {
                var ipAddress = ((IPEndPoint)state.RemotePeer).Address;
                CheckIfAddressIsMapped(ref ipAddress);
                if (!_clientsTable.Contains(state.RemotePeer))
                {
                    _clientsTable.Add(state.RemotePeer);
                    ConnectionCreated?.Invoke(ipAddress.ToString(), (ushort)((IPEndPoint)state.RemotePeer).Port);
                }

                // Compose callback data.
                var receivedData = new ReceivedDataArgs {
                    SourceName = ipAddress.ToString(), ListenerPort = PortNumber
                };
                receivedData.Data = new byte[bytesRecieved];
                Array.Copy(state.Data, receivedData.Data, bytesRecieved);
                DataReceived?.Invoke(receivedData);
                if (!SuppressDebugOutput)
                {
                    "Listener accepted {0} << {1}"._DLOG(receivedData.SourceName, Tools.GetHex(receivedData.Data));
                }
            }
        }