Esempio n. 1
1
        public TCPSocket(Socket from, bool socket_listening)
        {
            sock = from;
            listening = socket_listening;

            if (socket_listening)
            {
                IPEndPoint tmp = (IPEndPoint)sock.LocalEndPoint;
                port = (ushort)tmp.Port;
                ep = tmp;
            }
            else
            {
                IPEndPoint tmp = (IPEndPoint)sock.RemoteEndPoint;
                port = (ushort)tmp.Port;
                ep = tmp;
            }

            if (sock.Blocking == false)
            {
                sock.Blocking = true;
            }

            sock.ReceiveBufferSize = 1024 * 64; // 64 kb
            sock.SendBufferSize = 1024 * 64; // 64 kb
        }
        public override int DoRead(byte[] buffer)
        {
            System.Net.EndPoint endpoint = (System.Net.EndPoint)sendTarget;
            int size = client.ReceiveFrom(buffer, ref endpoint);

            return(size);
        }
Esempio n. 3
0
        public void Connect(EndPoint endPoint)
        {
            byte[] data = new byte[1024];
            string input, stringData;
            int recv;
            Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            int sockopt = (int)server.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout);
            Console.WriteLine("Default timeout: {0}", sockopt);
            server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, _timeout);
            sockopt = (int)server.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout);
            Console.WriteLine("New timeout: {0}", sockopt);

            string welcome = "Hello, are you there?";
            data = Encoding.ASCII.GetBytes(welcome);
            server.SendTo(data, data.Length, SocketFlags.None, endPoint);

            data = new byte[1024];
            try
            {
                Console.WriteLine("Waiting from {0}:", endPoint.ToString());
                recv = server.ReceiveFrom(data, ref endPoint);
                Console.WriteLine("Message received from {0}:", endPoint.ToString());
                Console.WriteLine(Encoding.ASCII.GetString(data, 0, recv));
            }
            catch (SocketException e)
            {
                if (e.SocketErrorCode == SocketError.HostUnreachable)
                    throw new Exception("CLOSED");
                throw new Exception("TIME_OUT");
            }
            Console.WriteLine("Stopping client");
            server.Close();
        }
Esempio n. 4
0
 internal EndpointI(Instance instance, string ho, int po, EndPoint sourceAddr, int ti, string conId, bool co)
     : base(instance, ho, po, sourceAddr, conId)
 {
     _instance = instance;
     _timeout = ti;
     _compress = co;
 }
        public UDPPacketBuffer()
        {
            this.Data = new byte[BUFFER_SIZE];

            // this will be filled in by the call to udpSocket.BeginReceiveFrom
            RemoteEndPoint = (EndPoint)new IPEndPoint(IPAddress.Any, 0);
        }
Esempio n. 6
0
 Task<ActiveConnectResult> IActiveConnector.ActiveConnect(EndPoint targetEndPoint)
 {
     var taskSource = new TaskCompletionSource<ActiveConnectResult>();
     var socket = new Socket(targetEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
     socket.BeginConnect(targetEndPoint, OnActiveConnectCallback, new ActiveConnectState(taskSource, socket));
     return taskSource.Task;
 }
Esempio n. 7
0
		protected UnixSocket (EndPoint localEndPoint)
			: base (System.Net.Sockets.AddressFamily.Unix,
			        System.Net.Sockets.SocketType.Stream,
			        System.Net.Sockets.ProtocolType.IP,
			        localEndPoint)
		{
		}
Esempio n. 8
0
        /// <summary>
        /// <see cref="AbstractTcpClient.ConnectInternal"/>
        /// </summary>
        protected override void ConnectInternal(Socket socket, EndPoint endpoint)
        {
            try
            {
                if (Object.ReferenceEquals(socket, null))
                {
                    socket = new Socket(
                        endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                }
                if (Object.ReferenceEquals(connectEventArgs, null))
                {
                    connectEventArgs = new SocketAsyncEventArgs();
                    connectEventArgs.Completed += OnConnectCompleted;
                }
                connectEventArgs.RemoteEndPoint = endpoint;
                connectEventArgs.UserToken = socket;

                bool pending = socket.ConnectAsync(connectEventArgs);
                if (!pending)
                {
                    OnConnect(connectEventArgs);
                }
            }
            catch (Exception e)
            {
                Log.Error("{0} error connecting to {1} : {2}",
                    Name, endpoint, e.Message);

                OnConnectError(socket, endpoint);
            }
        }
Esempio n. 9
0
        internal NetState(EndPoint ep)
        {
            EndPoint = ep;

            AddClient(this);
            LogLine("Connected");
        }
        public void BeginReceiveAll(byte[] buffer, int count, EndPoint remoteEndPoint)
        {
            ValidateTransferAllArguments(buffer, ref count);

            var transfered = 0;
            AsyncCallback callback = null;
            callback = result =>
            {
                var endPoint = result.AsyncState as EndPoint;
                if (endPoint == null)
                    return;

                var current = Socket.EndReceiveFrom(result, ref endPoint);
                if (current == 0)
                {
                    ReceiveCompleted?.Invoke(this, new TransferEventArgs(this, buffer, transfered, endPoint));
                    return;
                }

                transfered += current;
                if (transfered < current)
                    Socket.BeginReceiveFrom(buffer, transfered, count - transfered, SocketFlags.None, ref endPoint, callback, endPoint);
                else
                    ReceiveCompleted?.Invoke(this, new TransferEventArgs(this, buffer, transfered, endPoint));
            };

            Socket.BeginReceiveFrom(buffer, transfered, count - transfered, SocketFlags.None, ref remoteEndPoint, callback, remoteEndPoint);
        }
Esempio n. 11
0
 public NetworkDevice(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, EndPoint endPoint)
 {
     _AddressFamily = addressFamily;
     _SocketType = socketType;
     _ProtocolType = protocolType;
     _EndPoint = endPoint;
 }
Esempio n. 12
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="endPoint">Specifies endpoint of sender</param>
 /// <param name="msg">Message associated with event</param>
 /// <param name="_packet">Packet received</param>
 /// <param name="exception">Any exception, if occured</param>
 public NetEventArgs(EndPoint endPoint, string msg, NetPacket _packet, Exception exception)
 {
     this._endPoint = endPoint;
     this._msg = msg;
     this._packet = _packet;
     this._exception = exception;
 }
Esempio n. 13
0
        private void Connect_Click(object sender, EventArgs e)
        {
            try
            {
                epLocal = new IPEndPoint(IPAddress.Parse(IPClient_1.Text), Convert.ToInt32(PortClient_1.Text));
                sck.Bind(epLocal);

                epRemote = new IPEndPoint(IPAddress.Parse(IPClient_2.Text), Convert.ToInt32(PortClient_2.Text));
                sck.Connect(epRemote);

                byte[] buffer = new byte[1500];
                sck.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref epRemote, new AsyncCallback(MessageCallBack), buffer);

                Connect.Enabled = false;
                Send.Enabled = true;
                Сondition.Text = "Подключено";
                tbSend.Focus();

                form1.Form1_IPClient_1 = IPClient_1.Text; form1.Form1_IPClient_2 = IPClient_2.Text;
                form1.Form1_PortClient_1 = PortClient_1.Text; form1.Form1_PortClient_2 = PortClient_2.Text;
                form1.Player1.Text = NameClient_1.Text; form1.Player2.Text = NameClient_2.Text;
            }
            catch (Exception ex)
            {
                //MessageBox.Show(ex.ToString());
                MessageBox.Show("Проблема с подключением, проверте: \r\n - верно ли внесены сетевые настройки игры;\r\n - отсутствует сетевое подключение;\r\n - Ваш противник покинул игру или неуспел подключится.", "Oшибка!!!", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
            }
        }
Esempio n. 14
0
        public Connect(EndPoint remoteEndPoint)
        {
            if (remoteEndPoint == null)
                throw new ArgumentNullException("remoteEndPoint");

            _remoteEndPoint = remoteEndPoint;
        }
Esempio n. 15
0
        public EchoConnectionHandler(EndPoint remote, IActorRef connection)
        {
            // we want to know when the connection dies (without using Tcp.ConnectionClosed)
            Context.Watch(connection);

            Receive<Tcp.Received>(received =>
            {
                var text = Encoding.UTF8.GetString(received.Data.ToArray()).Trim();
                Console.WriteLine("Received '{0}' from remote address [{1}]", text, remote);
                if (text == "exit")
                    Context.Stop(Self);
                else
                    Sender.Tell(Tcp.Write.Create(received.Data));
            });
            Receive<Tcp.ConnectionClosed>(closed =>
            {
                Console.WriteLine("Stopped, remote connection [{0}] closed", remote);
                Context.Stop(Self);
            });
            Receive<Terminated>(terminated =>
            {
                Console.WriteLine("Stopped, remote connection [{0}] died", remote);
                Context.Stop(Self);
            });
        }
Esempio n. 16
0
        public void BeginConnectProxy(EndPoint remoteEP, AsyncCallback callback, object state)
        {
            // do nothing

            var r = new FakeAsyncResult(state);
            callback?.Invoke(r);
        }
Esempio n. 17
0
        public XSPWorker(Socket client, EndPoint localEP, ApplicationServer server,
			bool secureConnection,
			Mono.Security.Protocol.Tls.SecurityProtocolType SecurityProtocol,
			X509Certificate cert,
			PrivateKeySelectionCallback keyCB,
			bool allowClientCert,
			bool requireClientCert)
        {
            if (secureConnection) {
                ssl = new SslInformation ();
                ssl.AllowClientCertificate = allowClientCert;
                ssl.RequireClientCertificate = requireClientCert;
                ssl.RawServerCertificate = cert.GetRawCertData ();

                netStream = new LingeringNetworkStream (client, true);
                SslServerStream s = new SslServerStream (netStream, cert, requireClientCert, false);
                s.PrivateKeyCertSelectionDelegate += keyCB;
                s.ClientCertValidationDelegate += new CertificateValidationCallback (ClientCertificateValidation);
                stream = s;
            } else {
                netStream = new LingeringNetworkStream (client, false);
                stream = netStream;
            }

            sock = client;
            this.server = server;
            this.remoteEP = (IPEndPoint) client.RemoteEndPoint;
            this.localEP = (IPEndPoint) localEP;
        }
        public bool HandleFlood(EndPoint id)
        {
            if (_floods.ContainsKey(id))
            {
                FloodCount counter = _floods[id];
                counter.PacketCount++;
                _floods[id] = counter;

                if (counter.StopWatch.ElapsedMilliseconds > _msecTime)
                {
                    _floods.Remove(id);
                }
                else
                {
                    _floods.Remove(id);
                    return false;
                }
            }
            else
            {
                FloodCount counter = new FloodCount();
                counter.PacketCount = 1;
                counter.StopWatch.Start();

                _floods.Add(id, counter);

            }

            return true;
        }
Esempio n. 19
0
        State GetState(EndPoint ep, TimeSpan rtt)
        {
            if (_states == null) {
                lock (this) {
                    if (_state == null && !InvalidValue.Equals (rtt))
                        _state = new State ((int)rtt.TotalMilliseconds, _timerGranularity);
                    return _state;
                }
            }

            IPEndPoint ipep = ep as IPEndPoint;
            if (ipep == null)
                throw new ArgumentException ();

            State state;
            bool success;
            using (_lock.EnterReadLock ()) {
                success = _states.TryGetValue (ipep.Address, out state);
            }
            if (!success && !InvalidValue.Equals (rtt)) {
                using (_lock.EnterWriteLock ()) {
                    if (!_states.TryGetValue (ipep.Address, out state)) {
                        state = new State ((int)rtt.TotalMilliseconds, _timerGranularity);
                        _states.Add (ipep.Address, state);
                    }
                }
            }
            return state;
        }
Esempio n. 20
0
 public TimeSpan GetRTO(EndPoint ep)
 {
     State state = GetState (ep, InvalidValue);
     if (state == null)
         return _defaultRTO;
     return new TimeSpan (Math.Max (_minRTO, state.RTO) * TimeSpan.TicksPerMillisecond);
 }
Esempio n. 21
0
        /// <summary>
        /// This code is used to connect to a TCP socket with timeout option.
        /// </summary>
        /// <param name="endPoint">IP endpoint of remote server</param>
        /// <param name="timeoutMs">Timeout to wait until connect</param>
        /// <returns>Socket object connected to server</returns>
        public static Socket ConnectToServerWithTimeout(EndPoint endPoint, int timeoutMs)
        {
            var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                socket.Blocking = false;
                socket.Connect(endPoint);
                socket.Blocking = true;
                return socket;
            }
            catch (SocketException socketException)
            {
                if (socketException.ErrorCode != 10035)
                {
                    socket.Close();
                    throw;
                }

                if (!socket.Poll(timeoutMs * 1000, SelectMode.SelectWrite))
                {
                    socket.Close();
                    throw new NGRIDException("The host failed to connect. Timeout occured.");
                }

                socket.Blocking = true;
                return socket;
            }
        }
 // static methods
 internal static MongoWaitQueueFullException ForConnectionPool(EndPoint endPoint)
 {
     var message = string.Format(
         "The wait queue for acquiring a connection to server {0} is full.",
         EndPointHelper.ToString(endPoint));
     return new MongoWaitQueueFullException(message);
 }
 internal ServerCounters(EndPoint endpoint)
 {
     this.EndPoint = endpoint;
     this.Interactive = new ConnectionCounters(ConnectionType.Interactive);
     this.Subscription = new ConnectionCounters(ConnectionType.Subscription);
     this.Other = new ConnectionCounters(ConnectionType.None);
 }
Esempio n. 24
0
 public PolicyConnection(PolicyServer policyServer, Socket client, byte[] policy)
 {
     _policyServer = policyServer;
     _connection = client;
     _endpoint = _connection.RemoteEndPoint;
     _policy = policy;
     _buffer = new byte[_policyRequestString.Length];
     _received = 0;
     try
     {
         // Receive the request from the client                
         _connection.BeginReceive(_buffer, 0, _policyRequestString.Length, SocketFlags.None, new AsyncCallback(OnReceive), null);
     }
     catch (SocketException ex)
     {
         if (log.IsDebugEnabled)
             log.Debug("Socket exception", ex);
         _connection.Close();
     }
     catch (Exception ex)
     {
         if (log.IsErrorEnabled)
             log.Error("Failed starting a policy connection", ex);
     }
 }
Esempio n. 25
0
 protected override void CreateMessagingSocket(int idx, SymmetricKey key, out IMessagingSocket socket, out EndPoint endPoint)
 {
     endPoint = new IPEndPoint (_adrsGen.Next (), 10000);
     VirtualDatagramEventSocket sock = new VirtualDatagramEventSocket (_net, ((IPEndPoint)endPoint).Address);
     sock.Bind (endPoint);
     socket = new VirtualMessagingSocket (sock, true, _interrupter, DefaultRTO, DefaultRetryCount, 1024, 1024);
 }
Esempio n. 26
0
        private UdpChannel AddClient(System.Net.Sockets.Socket socket, System.Net.EndPoint remotpoint, string key)
        {
            UdpChannel channel = new UdpChannel(mSocket, this, remotpoint);

            OnConnected(channel);
            if (mConnectEA.Cancel)
            {
                channel.Dispose();
                return(null);
            }
            else
            {
                channel.ChannelDisposed = OnChannelDispose;
                channel.ChannelError    = OnChannelError;
                channel.ChannelReceive  = OnChannelReceive;
                channel.ChannelSend     = OnChannelSend;
                lock (mClients)
                {
                    mClients.Add(key, channel);

                    Version++;
                }
            }
            return(channel);
        }
		/// <summary>
		/// Constructor.
		/// </summary>
		/// <param name="hostEndPoint">Identifies a Network resource that this server is listening on.</param>
		/// <param name="bufferSize">Size of the buffer to use when receiving data from a connected client.</param>
		/// <param name="clientReadTimeout">amount of time that the server will wait 
		/// for a client to send data before timing the client out.</param>
		/// <param name="clientSendTimeout">amount of time that the server will wait 
		/// for a client to receive data before timing the client out.</param>
		public SocketServer(EndPoint hostEndPoint, int bufferSize, TimeSpan clientReadTimeout, TimeSpan clientSendTimeout)
		{
			_hostEndPoint = hostEndPoint;
			_bufferSize = bufferSize;
			_clientReadTimeout = clientReadTimeout;
			_clientSendTimeout = clientSendTimeout;
		}
Esempio n. 28
0
 public void Bind2(EndPoint ep)
 {
     if (ep == null)
         Bind(new IPEndPoint(IPAddress.Any, 0));
     else
         Bind(ep);
 }
Esempio n. 29
0
        public void beginWrite(EndPoint endpoint, Buffer buf)
        {
            if(!(endpoint is IPEndPoint))
            {
                throw new Ice.FeatureNotSupportedException("SOCKS4 does not support domain names");
            }
            else if(endpoint.AddressFamily != AddressFamily.InterNetwork)
            {
                throw new Ice.FeatureNotSupportedException("SOCKS4 only supports IPv4 addresses");
            }

            //
            // SOCKS connect request
            //
            IPEndPoint addr = (IPEndPoint)endpoint;
            buf.resize(9, false);
            ByteBuffer.ByteOrder order = buf.b.order();
            buf.b.order(ByteBuffer.ByteOrder.BIG_ENDIAN); // Network byte order.
            buf.b.position(0);
            buf.b.put(0x04); // SOCKS version 4.
            buf.b.put(0x01); // Command, establish a TCP/IP stream connection
            buf.b.putShort((short)addr.Port); // Port
            buf.b.put(addr.Address.GetAddressBytes()); // IPv4 address
            buf.b.put(0x00); // User ID.
            buf.b.position(0);
            buf.b.limit(buf.size());
            buf.b.order(order);
        }
        // constructors
        public BinaryConnection(ServerId serverId, EndPoint endPoint, ConnectionSettings settings, IStreamFactory streamFactory, IConnectionInitializer connectionInitializer, IEventSubscriber eventSubscriber)
        {
            Ensure.IsNotNull(serverId, nameof(serverId));
            _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint));
            _settings = Ensure.IsNotNull(settings, nameof(settings));
            _streamFactory = Ensure.IsNotNull(streamFactory, nameof(streamFactory));
            _connectionInitializer = Ensure.IsNotNull(connectionInitializer, nameof(connectionInitializer));
            Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber));

            _backgroundTaskCancellationTokenSource = new CancellationTokenSource();
            _backgroundTaskCancellationToken = _backgroundTaskCancellationTokenSource.Token;

            _connectionId = new ConnectionId(serverId);
            _receiveLock = new SemaphoreSlim(1);
            _sendLock = new SemaphoreSlim(1);
            _state = new InterlockedInt32(State.Initial);

            _commandEventHelper = new CommandEventHelper(eventSubscriber);
            eventSubscriber.TryGetEventHandler(out _failedEventHandler);
            eventSubscriber.TryGetEventHandler(out _closingEventHandler);
            eventSubscriber.TryGetEventHandler(out _closedEventHandler);
            eventSubscriber.TryGetEventHandler(out _openingEventHandler);
            eventSubscriber.TryGetEventHandler(out _openedEventHandler);
            eventSubscriber.TryGetEventHandler(out _failedOpeningEventHandler);
            eventSubscriber.TryGetEventHandler(out _receivingMessageEventHandler);
            eventSubscriber.TryGetEventHandler(out _receivedMessageEventHandler);
            eventSubscriber.TryGetEventHandler(out _failedReceivingMessageEventHandler);
            eventSubscriber.TryGetEventHandler(out _sendingMessagesEventHandler);
            eventSubscriber.TryGetEventHandler(out _sentMessagesEventHandler);
            eventSubscriber.TryGetEventHandler(out _failedSendingMessagesEvent);
        }
Esempio n. 31
0
        protected void Test1(IDatagramEventSocket[] sockets, EndPoint[] endPoints)
        {
            byte[] sendData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
            int recvIdx = -1, recvSize = -1;
            byte[] recvData = null;
            AutoResetEvent done = new AutoResetEvent (false);

            for (int i = 0; i < sockets.Length; i++) {
                sockets[i].Bind (endPoints[i]);
                sockets[i].Received += new DatagramReceiveEventHandler (delegate (object sender, DatagramReceiveEventArgs e) {
                    recvIdx = Array.IndexOf<IDatagramEventSocket> (sockets, sender as IDatagramEventSocket);
                    recvSize = e.Size;
                    recvData = (byte[])e.Buffer.Clone ();
                    done.Set ();
                });
            }

            for (int i = 0; i < sockets.Length; i++) {
                for (int k = 0; k < endPoints.Length; k++) {
                    sockets[i].SendTo (sendData, endPoints[k]);
                    done.WaitOne ();
                    Array.Resize<byte> (ref recvData, recvSize);
                    string id = "#" + (i + 1).ToString () + "." + (k + 1).ToString ();
                    Assert.AreEqual (k, recvIdx, id + ".1");
                    Assert.AreEqual (sendData.Length, recvSize, id + ".2");
                    Assert.AreEqual (sendData, recvData, id + ".3");
                }
            }
        }
    private void SetupSocket()
    {
      if (udpSocket.IsBound)
        throw new ApplicationException("The socket is already bound and receving.");

      //recieve data from any source 
      localIPEndPoint = new IPEndPoint(IPAddress.Any, targetPort);
      localEndPoint = (EndPoint)localIPEndPoint;

      //init Socket properties:
      udpSocket.SetSocketOption(SocketOptionLevel.Udp, SocketOptionName.NoDelay, 1);

      //allow for loopback testing 
      udpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);

      //extremly important to bind the Socket before joining multicast groups 
      udpSocket.Bind(localIPEndPoint);

      //set multicast flags, sending flags - TimeToLive (TTL) 
      // 0 - LAN 
      // 1 - Single Router Hop 
      // 2 - Two Router Hops... 
      udpSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, udpTTL);

      //join multicast group 
      udpSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse(targetIP)));

      NotifyMulticastSocketListener(MulticastSocketMessageType.SocketStarted, null);
    }
Esempio n. 33
0
        public void AddReeiveAlarm(System.Net.EndPoint ep, string server, string communication, string device, IO_PARAALARM alarm, bool result)
        {
            if (IOCenterManager.IsBackRun)
            {
                return;
            }
            //IP
            //            报警时间
            //IO参数
            //报警值
            //报警类型
            //报警等级
            //采集站
            //通道
            //设备
            //入库结果

            if (!ucEnableAlarm.Checked)
            {
                return;
            }

            ListViewItem lvi = new ListViewItem(ep.ToString());

            lvi.SubItems.Add(alarm.IO_ALARM_DATE);
            lvi.SubItems.Add(alarm.IO_LABEL + "[" + alarm.IO_NAME + "]");
            lvi.SubItems.Add(alarm.IO_ALARM_VALUE);
            lvi.SubItems.Add(alarm.IO_ALARM_TYPE);
            lvi.SubItems.Add(alarm.IO_ALARM_LEVEL);
            lvi.SubItems.Add(server);

            lvi.SubItems.Add(communication);
            lvi.SubItems.Add(device);
            if (result)
            {
                lvi.SubItems.Add("入库成功");
            }
            else
            {
                lvi.SubItems.Add("入库失败");
            }
            if (listViewAlarm.IsHandleCreated)
            {
                listViewAlarm.BeginInvoke(new EventHandler(delegate
                {
                    try
                    {
                        this.listViewAlarm.Items.Insert(0, lvi);
                        if (this.listViewAlarm.Items.Count > int.Parse(this.cbAlarmSize.SelectedValue))
                        {
                            this.listViewAlarm.Items.RemoveAt(this.listViewReceive.Items.Count - 1);
                        }
                    }
                    catch
                    {
                    }
                }));
            }
        }
Esempio n. 34
0
 private void CallDisconnected(System.Net.EndPoint from)
 {
     if (Disconnected != null)
     {
         Task task = new Task(() => Disconnected(from));
         task.Start();
     }
 }
Esempio n. 35
0
 private void Calldatareceived(System.Net.EndPoint from, byte[] data, int n)
 {
     if (datareceived != null)
     {
         Task task = new Task(() => datareceived(from, data, n));
         task.Start();
     }
 }
Esempio n. 36
0
        /// <inheritdoc/>
        public ISession GetSession(System.Net.EndPoint ep)
        {
            IPEndPoint ipEP = (IPEndPoint)ep;

            TLSSession sessionX = FindSession(ipEP);

            return(sessionX);
        }
Esempio n. 37
0
        // Send message to the network address
        private void SendMessage(Data message, System.Net.EndPoint receiver)
        {
            byte[] buffer = message.ToBytes();

            // Send datagram to the receiver
            serverSocket.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, receiver,
                                     new AsyncCallback(OnSend), receiver);
        }
Esempio n. 38
0
 protected virtual void HandleReceived(byte[] buffer, System.Net.EndPoint endPoint)
 {
     if (this._acceptor == null)
     {
         base._receiveBuffer.Append(buffer, 0, buffer.Length);
         this.HandlePackages();
     }
 }
 /// <summary>
 /// 接收UDP数据
 /// </summary>
 /// <param name="memory"></param>
 /// <param name="endPoint"></param>
 private async ValueTask Listener_UDPDataHandler(Memory <byte> memory, System.Net.EndPoint endPoint)
 {
     if (_appSessions.TryGetValue(endPoint.ToString(), out var appSession))
     {
         var readOnlymemory = (ReadOnlyMemory <byte>)memory;
         await FilterData(appSession, new ReadOnlySequence <byte>(readOnlymemory));
     }
 }
Esempio n. 40
0
 /// <summary>
 /// Initializes a UDP channel with the specific endpoint.
 /// We only support IP endpoints - so throw if it isn't one
 /// </summary>
 public UDPChannel(System.Net.EndPoint localEP)
 {
     _unicast = SocketSet.Find((IPEndPoint)localEP);
     if (_unicast != null)
     {
         throw new CoAPException("Cannot open the same address twice");
     }
     _unicast = new SocketSet((IPEndPoint)localEP);
 }
Esempio n. 41
0
        private void FireDataReceived(Byte[] data, System.Net.EndPoint ep, System.Net.EndPoint epLocal, TcpSession tcpSession)
        {
            EventHandler <DataReceivedEventArgs> h = DataReceived;

            if (h != null)
            {
                h(this, new DataReceivedEventArgs(data, ep, epLocal, tcpSession));
            }
        }
Esempio n. 42
0
        private void FireDataReceived(byte[] data, System.Net.EndPoint ep)
        {
            EventHandler <DataReceivedEventArgs> h = DataReceived;

            if (h != null)
            {
                h(this, new DataReceivedEventArgs(data, ep));
            }
        }
Esempio n. 43
0
        private System.Net.EndPoint recvEP;             // Receives the transmitting socket's endpoint

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="router">The associated message router.</param>
        public UdpChannel(MsgRouter router)
        {
            this.router          = router;
            this.isOpen          = false;
            this.sock            = null;
            this.port            = 0;
            this.recvEP          = new IPEndPoint(IPAddress.Any, 0);
            this.multicastInit   = false;
            this.broadcastClient = null;
        }
Esempio n. 44
0
 public IAsyncResult BeginConnect(n.EndPoint endpoint, AsyncCallback ac, object st)
 {
     n.IPEndPoint ipep = endpoint as n.IPEndPoint;
     if (endpoint == null)
     {
         throw new Exception("Sorry, guy... but this isn't in the scope of this class's purpose.");
     }
     attemptedConnectionEndpoint = ipep.Address.ToString();
     return(realsocket.BeginConnect(endpoint, ac, st));
 }
Esempio n. 45
0
 public IAsyncResult BeginConnect(n.EndPoint endpoint, AsyncCallback callback, object state)
 {
     n.IPEndPoint ipep = endpoint as n.IPEndPoint;
     if (endpoint == null)
     {
         throw new ArgumentNullException(nameof(endpoint));
     }
     attemptedConnectionEndpoint = ipep.Address.ToString();
     return(realSocket.BeginConnect(endpoint, callback, state));
 }
Esempio n. 46
0
 public void ForceDisconnect(System.Net.EndPoint clienttodisconnect)
 {
     foreach (ClientData client in clientlist)
     {
         if (clienttodisconnect == client.s.RemoteEndPoint)
         {
             handledisconnect(client);
         }
     }
 }
 protected override bool ConnectInternal(ModuleProc PROC, System.Net.EndPoint remoteEndpoint)
 {
     _handler                = new TcpClient(AddressFamily.InterNetwork);
     _handler.SendTimeout    = this.SendTimeout;
     _handler.ReceiveTimeout = this.ReceiveTimeout;
     _handler.Connect(_remoteEndPoint as IPEndPoint);
     _localEndPoint = _handler.Client.LocalEndPoint;
     _socket        = _handler.Client;
     this.WriteSocketLog("has been connected successfully.");
     return(true);
 }
Esempio n. 48
0
        private void FireDataReceived(Byte[] data, System.Net.EndPoint ep)
        {
#if LOG_UDP_CHANNEL
            _Log.Debug(m => m("FireDataReceived: data length={0}", data.Length));
#endif
            EventHandler <DataReceivedEventArgs> h = DataReceived;
            if (h != null)
            {
                h(this, new DataReceivedEventArgs(data, ep, this));
            }
        }
Esempio n. 49
0
 /// <inheritdoc/>
 public IEndPoint FindEndPoint(System.Net.EndPoint ep)
 {
     foreach (IEndPoint endpoint in _endpoints)
     {
         if (endpoint.LocalEndPoint.Equals(ep))
         {
             return(endpoint);
         }
     }
     return(null);
 }
Esempio n. 50
0
        public void TestInitialize()
        {
            clientEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50050);
            serverEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 50060);
            //easyClient = new EasyClient();
            //appServer = new AppServer();

            //Assert.IsTrue(appServer.Setup("127.0.0.1", 50060));

            //Assert.IsTrue(appServer.Start());
        }
Esempio n. 51
0
        //  从EndPoint提取IP地址字符串
        private string EndPointToStr(System.Net.EndPoint ePoint)
        {
            string IPPoint = ePoint.ToString();
            string IPStr   = "";

            if (IPPoint.IndexOf(":") >= 0)
            {
                IPStr = IPPoint.Substring(0, IPPoint.IndexOf(":"));
            }
            return(IPStr);
        }
Esempio n. 52
0
        private void baseListen()
        {
            bool flag = true;

            while (this.isListening)
            {
                byte[] array = new byte[63488];
                System.Net.EndPoint endPoint = null;
                try
                {
                    endPoint          = new System.Net.IPEndPoint(this.ipAddress, this.port);
                    this.serverSocket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
                    this.serverSocket.Bind(endPoint);
                    if (flag)
                    {
                        DebugCenter.GetInstance().clearStatusCode(DebugCenter.ST_TrapPortNA, true);
                        flag = false;
                    }
                    this.serverSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, System.Net.Sockets.SocketOptionName.ReceiveTimeout, 0);
                    int num = this.serverSocket.ReceiveFrom(array, System.Net.Sockets.SocketFlags.None, ref endPoint);
                    if (num > 0 && this.isListening)
                    {
                        string[] separator = new string[]
                        {
                            ":"
                        };
                        string[]       array2         = endPoint.ToString().Split(separator, System.StringSplitOptions.None);
                        SocketMessager socketMessager = new SocketMessager();
                        socketMessager.Target    = array2[0];
                        socketMessager.Port      = System.Convert.ToInt32(array2[1]);
                        socketMessager.DataLenth = num;
                        socketMessager.DataBytes = array;
                        System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(this.waitCallback), socketMessager);
                    }
                }
                catch (System.Exception)
                {
                    try
                    {
                        System.Threading.Thread.Sleep(100);
                    }
                    catch (System.Exception)
                    {
                    }
                }
                finally
                {
                    if (this.serverSocket != null)
                    {
                        this.serverSocket.Close();
                    }
                }
            }
        }
        private async Task <ClusterMessages.ClusterInfo> TryGetGossipFrom(EndPoint gossipSeed)
        {
            if (!_gossipClients.TryGetValue(gossipSeed, out var client))
            {
                client = _gossipClientFactory(gossipSeed);
                _gossipClients[gossipSeed] = client;
            }

            var clusterInfoDto = await client.ReadAsync(new Empty());

            return(ConvertGrpcClusterInfo(clusterInfoDto));
        }
Esempio n. 54
0
        public void AddReeiveDevice(System.Net.EndPoint ep, string datetime, string server, string communication, string device, string msg, bool result)
        {
            if (IOCenterManager.IsBackRun)
            {
                return;
            }

            if (!ucReceive.Checked)
            {
                return;
            }
            ListViewItem lvi = new ListViewItem(ep.ToString());

            lvi.SubItems.Add(datetime);
            lvi.SubItems.Add(device);
            lvi.SubItems.Add(communication);
            lvi.SubItems.Add(server);
            if (msg.Length > 900)
            {
                lvi.SubItems.Add(msg.Substring(0, 900) + "......");
            }
            else
            {
                lvi.SubItems.Add(msg);
            }

            if (result)
            {
                lvi.SubItems.Add("入库成功");
            }
            else
            {
                lvi.SubItems.Add("入库失败");
            }
            if (listViewReceive.IsHandleCreated)
            {
                listViewReceive.BeginInvoke(new EventHandler(delegate
                {
                    try
                    {
                        this.listViewReceive.Items.Insert(0, lvi);
                        if (this.listViewReceive.Items.Count > int.Parse(cbReceiveSize.SelectedValue))
                        {
                            this.listViewReceive.Items.RemoveAt(this.listViewReceive.Items.Count - 1);
                        }
                    }
                    catch
                    {
                    }
                }));
            }
        }
Esempio n. 55
0
        public void Send(byte[] data, System.Net.EndPoint ep)
        {
            RawData raw = new RawData();

            raw.Data     = data;
            raw.EndPoint = ep;
            _SendingQueue.Enqueue(raw);
            if (System.Threading.Interlocked.CompareExchange(ref _Writing, 1, 0) > 0)
            {
                return;
            }
            BeginSend();
        }
Esempio n. 56
0
            public void Add(IPAddress address, byte[] response, System.Net.EndPoint remoteEp)
            {
                var result = Message.Parse(response, remoteEp as IPEndPoint, address);

                if (result != null)
                {
                    var resultKey  = address.ToString();
                    var targetDict = m_resultMap.GetOrAdd(resultKey, new ConcurrentDictionary <TargetType, ConcurrentDictionary <string, Result> >());
                    var resultDict = targetDict.GetOrAdd(result.Target.Type, new ConcurrentDictionary <string, Result>());

                    resultDict.AddOrUpdate(result.Key(), result, (key, value) => result);
                }
            }
Esempio n. 57
0
        static void server_Offline(object sender, System.Net.EndPoint client)
        {
            IPEndPoint ep = client as IPEndPoint;

            if (ep != null)
            {
                Logs.Create("与客户端[" + ep.Address + "]的连接已断开!");
            }
            if (ClientOffline != null)
            {
                ClientOffline(sender, client);
            }
        }
Esempio n. 58
0
        private static void Server_OnWriteRequest(ITftpTransfer transfer, System.Net.EndPoint client)
        {
            String file = Path.Combine(ServerDirectory, transfer.Filename);

            if (File.Exists(file))
            {
                CancelTransfer(transfer, TftpErrorPacket.FileAlreadyExists);
            }
            else
            {
                OutputTransferStatus(transfer, "Accepting write request from " + client);
                StartTransfer(transfer, new FileStream(file, FileMode.CreateNew));
            }
        }
Esempio n. 59
0
        /// <inheritdoc/>
        public void Send(Byte[] data, System.Net.EndPoint ep)
        {
            RawData raw = new RawData();

            raw.Data     = data;
            raw.EndPoint = ep;
            _sendingQueue.Enqueue(raw);
            log.Info($"UDP-Enqueued {ep.Serialize()}({data?.Length})");
            if (System.Threading.Interlocked.CompareExchange(ref _writing, 1, 0) > 0)
            {
                return;
            }
            BeginSend();
        }
Esempio n. 60
0
        public void OnIPC(System.Net.Sockets.Socket aSocket, System.Net.EndPoint ep, byte[] data)
        {
            try
            {
                if (data.Length >= 6)
                {
                    /*string str;
                     * System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
                     * str = enc.GetString(data);*/

                    string[] ip_s = ep.ToString().Split(':');

                    Systems.SRX_Serverinfo remoteGameServer = Systems.GetServerByEndPoint(ip_s[0], UInt16.Parse(ip_s[1]));
                    if (remoteGameServer != null)
                    {
                        // decode data
                        //Network.Servers.IPCdeCode(ref data, remoteGameServer.code);

                        Systems.PacketReader pack = new Systems.PacketReader(data);
                        short pcmd = pack.Int16();
                        if (data.Length >= 6)
                        {
                            switch (pcmd)
                            {
                            default:
                                LogDebug.Show("[IPC] unknown command recevied {0:x}", pcmd);
                                break;
                            }
                        }
                        else
                        {
                            LogDebug.Show("[IPC] data to short");
                        }
                    }
                    else
                    {
                        LogDebug.Show("[IPC] can't find the GameServer {0}:{1}", ((IPEndPoint)ep).Address.ToString(), ip_s[1]);
                    }
                }
                else
                {
                    LogDebug.Show("[IPC] packet to short from {0}", ep.ToString());
                }
            }
            catch (Exception ex)
            {
                LogDebug.Show("[IPC.OnIPC] {0}", ex);
            }
        }