Inheritance: IDisposable
        public ServerContext(int port, int maxclients, ref List<string> TextStack, string OwnIP)
        {
            BeginSendUdpServerCallback = new AsyncCallback(OnBeginSendUdpServerCallbackFinished);
            ServerMessage = System.Text.Encoding.ASCII.GetBytes("OK:" + OwnIP);

            UdpServer = new UdpClient(new IPEndPoint(IPAddress.Any, 8011)); //da bei xp fehler

            UdpServer.JoinMulticastGroup(BroadcastServer.Address);

            UdpServer.BeginSend(ServerMessage, ServerMessage.Length, BroadcastServer, BeginSendUdpServerCallback, null);

            MaxClients = maxclients;

            Ip = IPAddress.Any;
            this.Port = port;

            listener = new TcpListener(Ip, Port);
            Clients = new List<ClientContext>(MaxClients);

            listener.Start();

            BeginAcceptSocketCallback = new AsyncCallback(OnClientConnected);

            this.TextStack = TextStack;
        }
Example #2
1
        /*
        // TODO: Асинхронная отправка! Или не нужно?
        /// <summary>
        /// Отправить единичное сообщение на единичный хост
        /// </summary>
        /// <param name="text">Текст сообщения</param>
        // internal static void SendMessage(string RemoteHost, string text)
        {
            TcpClient client = null;
            NetworkStream networkStream = null;
            try
            {
                IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 12000);
                // TODO : заменить 127.0.0.1 на что-то более верное
                // TODO: добавить динамическое выделение портов (из пула свободных портов)
                // получатель сообщения при
                IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(RemoteHost), 11000);
                // TODO :забить номера портов в настройки
                client = new TcpClient(localEndPoint);

                client.Connect(remoteEndPoint);

                networkStream = client.GetStream();
                byte[] sendBytes = Encoding.UTF8.GetBytes(text);
                networkStream.Write(sendBytes, 0, sendBytes.Length);
                byte[] bytes = new byte[client.ReceiveBufferSize];
                networkStream.Read(bytes, 0, client.ReceiveBufferSize);
                string returnData = Encoding.UTF8.GetString(bytes);
                //MessageBox.Show(returnData);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                if (networkStream != null) networkStream.Close();
                if (client!=null) client.Close();

            }

        }
        */
        // реализаця с UDP
        internal static void SendMessage(string RemoteHost, string text)
        {
            UdpClient client = null;
            try
            {
                IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 12000);

                // получатель сообщения при
                IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(RemoteHost), 11000);
                // TODO :забить номера портов в настройки
                client = new UdpClient(localEndPoint);

                byte[] sendBytes = Encoding.ASCII.GetBytes(text);
                networkStream.Write(sendBytes, 0, sendBytes.Length);
                byte[] bytes = new byte[client.ReceiveBufferSize];
                networkStream.Read(bytes, 0, client.ReceiveBufferSize);
                string returnData = Encoding.UTF8.GetString(bytes);
                //MessageBox.Show(returnData);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                if (networkStream != null) networkStream.Close();
                if (client != null) client.Close();

            }
        }
Example #3
0
 // Use this for initialization
 void Start()
 {
     client = new System.Net.Sockets.UdpClient();
     ep     = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8000);
     client.Connect(ep);
     InvokeRepeating("sendPos", 0.0f, 0.0167f);
 }
Example #4
0
        public override void Send(string serverHostName, string serverIpAddress, int serverPort, string message)
        {
            var ipAddress = IPAddress.Parse(serverIpAddress);
            IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, serverPort);

            using(UdpClient udpClient = new UdpClient()){
                var gzipMessage = GzipMessage(message);

                if (MaxChunkSize < gzipMessage.Length)
                {
                    var chunkCount = gzipMessage.Length / MaxChunkSize + 1;
                    var messageId = GenerateMessageId(serverHostName);
                    for (int i = 0; i < chunkCount; i++)
                    {
                        var messageChunkPrefix = CreateChunkedMessagePart(messageId, i, chunkCount);
                        var skip = i * MaxChunkSize;
                        var messageChunkSuffix = gzipMessage.Skip(skip).Take(MaxChunkSize).ToArray<byte>();

                        var messageChunkFull = new byte[messageChunkPrefix.Length + messageChunkSuffix.Length];
                        messageChunkPrefix.CopyTo(messageChunkFull, 0);
                        messageChunkSuffix.CopyTo(messageChunkFull, messageChunkPrefix.Length);

                        udpClient.Send(messageChunkFull, messageChunkFull.Length, ipEndPoint);
                    }
                }
                else
                {
                    udpClient.Send(gzipMessage, gzipMessage.Length, ipEndPoint);
                }
            }
        }
Example #5
0
 public void Send(byte[] datagram, int bytes, IPEndPoint ipEndPoint)
 {
     using (var udpClient = new UdpClient())
     {
         udpClient.Send(datagram, bytes, ipEndPoint);
     }
 }
Example #6
0
        public static void Init(TestContext context)
        {
            Trace.Listeners.Add(new ConsoleTraceListener());
            //Helper.Driver.Profile.DriverPath = "E:\\Workbench\\ZeroHub\\ZeroHub\\SharpNetUnitTest\\bin\\Debug\\Drivers\\";
            //Helper.Driver.Uninstall();
            //Helper.Driver.Install();
            LocalIP       = "10.3.0.1";
            RemoteIPRange = "10.3.0.0"; // RemoteIPRange & Mask , and filter away local
            RemoteIP      = "10.3.0.5";
            Mask          = "255.255.255.0";

            net = new SharpNet();
            net.Tap.SetMediaStatus(true);
            net.Tap.ConfigTun(LocalIP, RemoteIPRange, Mask);
            net.Tap.SetIpAddress(LocalIP, Mask, "10.3.0.0");

            //net.Tap.ConfigDHCPMASQ("192.168.137.1", "255.255.255.255", "1.1.1.1", 2);
            Task.Delay(TimeSpan.FromSeconds(5)).Wait();

            ping       = new Ping();
            localPort  = 233;
            remotePort = 233;

            local  = new IPEndPoint(IPAddress.Parse(LocalIP), localPort);
            remote = new IPEndPoint(IPAddress.Parse(RemoteIP), remotePort);
            //remote = new IPEndPoint(IPAddress.Any, remotePort);
            client = new System.Net.Sockets.UdpClient(local);
        }
Example #7
0
        private static void ReceiveMessage()
        {
            System.Net.Sockets.UdpClient receiver = new System.Net.Sockets.UdpClient(LOCAL_PORT);     // UdpClient for receiving incoming data

            // IPEndPoint remoteIp = new IPEndPoint(IPAddress.Parse("80.234.45.88"), 8888); // address of the sending server
            IPEndPoint remoteIp = null; // address of the sending server (NULL means Any)

            try
            {
                while (true)
                {
                    byte[] data = receiver.Receive(ref remoteIp);     // receive data from the server

                    // string message = Encoding.Unicode.GetString(data);
                    //Console.WriteLine("server data: {0}", message);


                    Console.WriteLine($"Received broadcast from {remoteIp}");
                    Console.WriteLine($" {Encoding.ASCII.GetString(data, 0, data.Length)}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                receiver.Close();
            }
        }
 private async void ReceiveData(UdpReceiveResult result, UdpClient client)
 {
     try
     {
         System.Net.Sockets.UdpClient listener = client;
         byte[] data = result.Buffer;
         endpoint = result.RemoteEndPoint;
Example #9
0
 private bool Connect(string ip, int port)
 {
     try
     {
         if (port == 0 || ip == "")
         {
             return(false);
         }
         Debug.Log("connect battle udp-server " + ip + ":" + port);
         this.TryCloseSocket();
         IPAddress     ipAddress;
         AddressFamily af;
         bool          ok = Misc.Utils.IPV4ToIPV6(ip, out ipAddress, out af);
         _server_endpoint = new IPEndPoint(ipAddress, port);
         _inner_socket    = new UdpClient();
         _inner_socket.Connect(_server_endpoint);
         _inner_socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, 1024 * 16);
         _inner_socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, 1024 * 32);
         this.isConnected = true;
     }
     catch (Exception e)
     {
         this.isConnected = false;
         _inner_socket    = null;
         Debug.Log(e.Message);
         return(false);
     }
     return(true);
 }
Example #10
0
 /// <summary>
 /// Connect to specific remote end point and only send and receive from that endpoint.
 /// </summary>
 /// <param name="endPoint"></param>
 public void Connect(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint)
 {
     this.remoteEndPoint = remoteEndPoint;
     udp = new UdpClient(localEndPoint);
     receivingPending = true;
     udp.BeginReceive(new AsyncCallback(OnPacketReceived), this);
 }
Example #11
0
        // Connect for receiving messages
        public bool Connect(int localPort)
        {
            Disconnect();
            receiveDone.Reset();
            // Connect to a local port.
            try
            {
                localEP = new IPEndPoint(IPAddress.Any, localPort);

                // Create a UDP Client.
                clientReceive = new System.Net.Sockets.UdpClient(localEP);

                if (ConnectedStateChanged != null) ConnectedStateChanged(this, new ConnectedStateChangedEventArgs(true));

                // Setup the receiver client thread
                receiverTask = new Thread(ReceiverLoop);
                receiverTask.Start();

                // Signal that the connection has been made.
                connectDone.Set();
            }
            catch (Exception e)
            {
                Disconnect();
                //
                Console.WriteLine(e.ToString());
            }

            return IsConnected;
        }
Example #12
0
        private bool startListen()
        {
            try
            {
                if (tcpListener == null)
                    tcpListener = new TcpListener(IPAddress.Any, tcpPort);

                if (udpClient == null || udpClosed)
                {
                    udpClient = new UdpClient(udpPort);
                    //udpClient = new UdpClient(udpPort, AddressFamily.InterNetwork);
                    udpClosed = false;
                }

                if (udpListenThread == null || !udpListenThread.IsAlive)
                {
                    udpListenThread = new Thread(new ThreadStart(listenForUdpClients));
                    udpListenThread.IsBackground = true;
                    udpListenThread.Start();
                }
                if (tcpListenThread == null || !tcpListenThread.IsAlive)
                {
                    tcpListenThread = new Thread(new ThreadStart(listenForTcpClients));
                    tcpListenThread.IsBackground = true;
                    tcpListenThread.Start();
                }
                Trace.WriteLine("Server started on TCP-Port: " + tcpPort + " and UDP-Port: " + udpPort);
                return true;
            }
            catch
            {
                Trace.WriteLine("Couldn't start server on Tcp-Port: " + tcpPort + " and Udp-Port: " + udpPort);
                return false;
            }
        }
Example #13
0
 /// <summary>
 /// Stops the UDP client.
 /// </summary>
 /// <param name="udpClient">The UDP client.</param>
 public static void StopUDPClient(UdpClient udpClient)
 {
     if (udpClient != null)
     {
         udpClient.Close();
     }
 }
Example #14
0
        //データを受信した時
        private void ReceiveCallback(IAsyncResult ar)
        {
            System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState;

            //非同期受信を終了する
            System.Net.IPEndPoint remoteEP = null;
            byte[] rcvBytes;
            try
            {
                rcvBytes = udp.EndReceive(ar, ref remoteEP);
            }
            catch (System.Net.Sockets.SocketException ex)
            {
                Console.WriteLine("受信エラー({0}/{1})",
                                  ex.Message, ex.ErrorCode);
                return;
            }
            catch (ObjectDisposedException ex)
            {
                //すでに閉じている時は終了
                Console.WriteLine("Socketは閉じられています。");
                return;
            }

            RecieveData(remoteEP.Address, remoteEP.Port, rcvBytes);


            //再びデータ受信を開始する
            udp.BeginReceive(ReceiveCallback, udp);
        }
Example #15
0
        //データを受信した時
        private void ReceiveCallback(IAsyncResult ar)
        {
            System.Net.Sockets.UdpClient udp =
                (System.Net.Sockets.UdpClient)ar.AsyncState;

            //非同期受信を終了する
            System.Net.IPEndPoint remoteEP = null;
            byte[] rcvBytes;
            try
            {
                rcvBytes = udp.EndReceive(ar, ref remoteEP);
            }
            catch (System.Net.Sockets.SocketException ex)
            {
                Console.WriteLine("Error({0}/{1})",
                                  ex.Message, ex.ErrorCode);
                return;
            }
            catch (ObjectDisposedException ex)
            {
                //すでに閉じている時は終了
                Console.WriteLine("Socket closed");
                return;
            }

            //データを文字列に変換する
            string rcvMsg = System.Text.Encoding.UTF8.GetString(rcvBytes);
            var    e      = new UDP_ReceiveData(rcvMsg, remoteEP.Address.ToString());

            Console.WriteLine("datarecived:{0}", rcvMsg);
            packet_receive(this, e);

            //再びデータ受信を開始する
            udp.BeginReceive(ReceiveCallback, udp);
        }
        public WirelessMouse()
        {
            _mListener = new UdpClient(5051);
            _mEndPoint = new IPEndPoint(IPAddress.Any, 5051);

            Sensitivity = 10;
        }
Example #17
0
        /// <summary>
        /// Does the video job.
        /// </summary>
        private void DoWorkerJob(System.Net.Sockets.UdpClient socket, int data_port)
        {
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, data_port);

            try
            {
                // loop until we get an exception eg the socket closed
                while (true)
                {
                    byte[] frame = socket.Receive(ref ipEndPoint);

                    // We have an RTP frame.
                    // Fire the DataReceived event with 'frame'
                    //Console.WriteLine("Received RTP data on port " + data_port);

                    Rtsp.Messages.RtspChunk currentMessage = new Rtsp.Messages.RtspData();
                    // aMessage.SourcePort = ??
                    currentMessage.Data = frame;
                    ((Rtsp.Messages.RtspData)currentMessage).Channel = data_port;


                    OnDataReceived(new Rtsp.RtspChunkEventArgs(currentMessage));
                }
            }
            catch (ObjectDisposedException)
            {
            }
            catch (SocketException)
            {
            }
        }
Example #18
0
 /// <summary>
 ///     Default constructor for <code>UdpSocketClient.</code>
 /// </summary>
 public UdpSocketClient()
 {
     _backingUdpClient = new UdpClient
     {
         EnableBroadcast = true
     };
 }
Example #19
0
        private static bool hostname_port_Validate(string hostname, int port)
        {
            bool no_error = true;

            try {
                // When hostname is not recognized as an ip address,
                //  UdpClient take it as an hostname and
                //  try to resolve it using network.
                // So it could take some times.
                // So I do not use it.
//                System.Net.Sockets.UdpClient udp = new System.Net.Sockets.UdpClient(hostname, port);

                // Parse accepts many things as ip address :
                // 127.0.0    127.0    127    6543
                System.Net.IPAddress ipadd;
                no_error = System.Net.IPAddress.TryParse(hostname, out ipadd);

                if (no_error)
                {
                    System.Net.Sockets.UdpClient udp = new System.Net.Sockets.UdpClient(hostname, port);
                }
            }
            catch (Exception)
            {
                no_error = false;
            }

            return(no_error);
        }
Example #20
0
 private void listen()
 {
     UdpClient uc = new UdpClient(9527);//udp协议添加端口号
     while (true)
     {
         IPEndPoint ipep = new IPEndPoint(IPAddress.Any,0);//将网络端点转化为ip地址 和端口号
         byte[] bmsg = uc.Receive(ref ipep);//返回有远程主机发出的udp数据报
         string msg = Encoding.Default.GetString(bmsg);//将字节转化为文本
         string[] s = msg.Split('|');//元素分隔
         if(s.Length != 4)
         {
             continue;
         }
         if(s[0]=="LOGIN")
           {
               Friend friend=new Friend();
               int curIndex = Convert.ToInt32(s[2]);
               if (curIndex<0 || curIndex>=this.ilHeadImages.Images.Count)
                  {
                      curIndex = 0;
                  }
               friend.HeadImageIndex =curIndex;
               friend.NickName = s[1];
               friend.Shuoshuo=s[3];
               object[] pars=new object[1];
               pars[0]=friend;
               this.Invoke(new delAddFriend(this.addUcf),pars[0]);
           }
     }
 }
        protected override void Loop(CancellationToken token)
        {
            using (var udpClient = new UdpClient(NavdataPort))
            {
                udpClient.Connect(_configuration.DroneHostname, NavdataPort);

                SendKeepAliveSignal(udpClient);

                var droneEp = new IPEndPoint(IPAddress.Any, NavdataPort);
                Stopwatch swKeepAlive = Stopwatch.StartNew();
                Stopwatch swNavdataTimeout = Stopwatch.StartNew();
                while (token.IsCancellationRequested == false &&
                       swNavdataTimeout.ElapsedMilliseconds < NavdataTimeout)
                {
                    if (udpClient.Available > 0)
                    {
                        byte[] data = udpClient.Receive(ref droneEp);
                        var packet = new NavigationPacket
                            {
                                Timestamp = DateTime.UtcNow.Ticks,
                                Data = data
                            };
                        _navigationPacketAcquired(packet);
                        swNavdataTimeout.Restart();
                    }

                    if (swKeepAlive.ElapsedMilliseconds > KeepAliveTimeout)
                    {
                        SendKeepAliveSignal(udpClient);
                        swKeepAlive.Restart();
                    }
                    Thread.Sleep(5);
                }
            }
        }
        protected void serverLoop()
        {
            Trace.WriteLine("Waiting for UDP messages.");
            listener = new UdpClient(UDP_PORT);
            IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, UDP_PORT);
            byte[] receive_byte_array;

            bool running = true;
            while (running)
            {
                try
                {
                    receive_byte_array = listener.Receive(ref groupEP);
                    if (receive_byte_array.Length != 2)
                    {
                        Trace.WriteLine("Invalid UDP message received. Ignored message!");
                        continue;
                    }

                    Trace.WriteLine("Upp fan speed message received.");
                    int fan = receive_byte_array[0];
                    byte speed = receive_byte_array[1];
                    fanControlDataObject.setPinSpeed(fan, speed, true);
                }
                catch
                {
                    running = false;
                }
            }
        }
Example #23
0
 // Start is called before the first frame update
 void Start()
 {
     //UdpClientオブジェクトを作成する
     udp = new System.Net.Sockets.UdpClient();
     udp.EnableBroadcast = true;
     udp.Connect(new IPEndPoint(IPAddress.Broadcast, remotePort));
 }
Example #24
0
        public SoundProxy(string branch, SipTransportBase sipProxy)
        {
            if (null == sipProxy)
            {
                throw new ArgumentNullException("settings");
            }
            if (null == branch)
            {
                throw new ArgumentNullException("branch");
            }
            if (0 == branch.Length)
            {
                throw new ArgumentException("Branch not specified.");
            }
            if (branch.Length > 250)
            {
                throw new ArgumentException("Branch is too long.", "branch");
            }

            m_SipTransport = sipProxy;
            m_BranchAscii  = SipTransportBase.g_Ascii.GetBytes(branch);

            m_udpClient = new System.Net.Sockets.UdpClient(
                new NET.IPEndPoint(m_SipTransport.LocalAddress, 0)
                );

            m_udpReceiveThread = new System.Threading.Thread(UdpReceiveProc);
            m_udpReceiveThread.Start();
        }
Example #25
0
        public ReliableUDPListener(UdpClient udp)
        {
            this.Udp = udp;

            this.RecieveThread = new Thread(ProcRecieve);
            this.RecieveThread.Start();
        }
Example #26
0
        // Connect for receiving messages
        public bool Connect(int localPort)
        {
            Disconnect();
            receiveDone.Reset();
            // Connect to a local port.
            try
            {
                localEP = new IPEndPoint(IPAddress.Any, localPort);

                // Create a UDP Client.
                clientReceive = new System.Net.Sockets.UdpClient(localEP);

                if (ConnectedStateChanged != null)
                {
                    ConnectedStateChanged(this, new ConnectedStateChangedEventArgs(true));
                }

                // Setup the receiver client thread
                receiverTask = new Thread(ReceiverLoop);
                receiverTask.Start();

                // Signal that the connection has been made.
                connectDone.Set();
            }
            catch (Exception e)
            {
                Disconnect();
                //
                Console.WriteLine(e.ToString());
            }

            return(IsConnected);
        }
Example #27
0
    public void ReceiveCallback(System.IAsyncResult ar)
    {
        System.Net.Sockets.UdpClient u = (System.Net.Sockets.UdpClient)((UdpState)(ar.AsyncState)).u;
        System.Net.IPEndPoint        e = (System.Net.IPEndPoint)((UdpState)(ar.AsyncState)).e;
        var receiveBytes = u.EndReceive(ar, ref e);

        Debug.Log(BitConverter.ToString(receiveBytes));
        int pos = 16; // 16バイトから開始

        int width = 0;

        for (int i = 0; i < 4; i++)
        {
            width = width * 256 + receiveBytes[pos++];
        }

        int height = 0;

        for (int i = 0; i < 4; i++)
        {
            height = height * 256 + receiveBytes[pos++];
        }

        ReceiveBytes = receiveBytes;

        H = height;
        W = width;

        received = true;
    }
Example #28
0
 public void Connect()
 {
     try
     {
         System.Net.IPHostEntry       hostEntry = System.Net.Dns.GetHostEntry(this.TimeServer);
         System.Net.IPEndPoint        endPoint  = new System.Net.IPEndPoint(hostEntry.AddressList[0], 123);
         System.Net.Sockets.UdpClient udpClient = new System.Net.Sockets.UdpClient();
         udpClient.Client.ReceiveTimeout = 3000;
         udpClient.Client.SendTimeout    = 3000;
         udpClient.Connect(endPoint);
         this.Initialize();
         udpClient.Send(this.NTPData, this.NTPData.Length);
         this.NTPData            = udpClient.Receive(ref endPoint);
         this.ReceptionTimestamp = System.DateTime.Now;
         if (!this.IsResponseValid())
         {
             throw new System.Exception("Invalid response from " + this.TimeServer);
         }
     }
     catch (System.Net.Sockets.SocketException ex)
     {
         Log.WriteError("NTPʱ¼ä»ñȡʧ°Ü£º" + ¡¡ex.Message);
         throw new System.Exception(ex.Message);
     }
 }
Example #29
0
        public GDISendingChannel(GDIDeviceContext dc)
        {
            fFormatter = new BinaryFormatter();
            fMemoryStream = new MemoryStream(2048);

            fDeviceContext = dc;

            // Create the client
            fGDISpeaker = new UdpClient();

            // Create the broadcast socket
            IPAddress ip = IPAddress.Parse(GDIPortal.Multicast_Pixtour_Group);
            fBroadcastSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            fBroadcastSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(ip));
            fBroadcastSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 255);

            IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(GDIPortal.Multicast_Pixtour_Group), GDIPortal.Multicast_Pixtour_Port);
            fBroadcastSocket.Connect(ipep);


            // Setup the speaker
            fGraphPort = new GCDelegate(fDeviceContext.Resolution);
            fGraphPort.CommandPacked += new GCDelegate.DrawCommandProc(CommandPacked);


            // Setup the antennae to listen for commands
            fReceiver = new GDIReceivingChannel(GDIPortal.Multicast_Pixtour_Group, GDIPortal.Multicast_Pixtour_Port, fDeviceContext);
        }
Example #30
0
        public void Stop()
        {
            _IsStarted = false;

            SockThread.Join();
            udpclient = null;
        }
Example #31
0
        public void Listen()
        {
            using (var udpClient = new UdpClient(_listenPort))
            {
                _listen = true;
                var remoteEp = new IPEndPoint(IPAddress.Any, _listenPort);
                while (_listen)
                {
                    var data = udpClient.Receive(ref remoteEp);
                    if (data.Length <= 0)
                    {
                        continue;
                    }

                    if (_messageQueue.Count > _messageFloodLimit) //Overflow
                    {
                        continue;
                    }

                    var rawMessage = new RawMessage()
                    {
                        Port = remoteEp.Port,
                        IpAddress = remoteEp.Address,
                        Message = System.Text.Encoding.UTF8.GetString(data)
                    };

                    _messageQueue.Enqueue(rawMessage);
                }

                udpClient.Close();
            }
        }
Example #32
0
 public XPlaneData(string remoteHost, int remotePort = 49000, string localHost = "127.0.0.1", int localPort = 49010)
 {
     _remoteEP = new IPEndPoint(IPAddress.Parse(remoteHost), remotePort);
     _localEP = new IPEndPoint(IPAddress.Parse(localHost), localPort);
     _udpClient = new UdpClient();
     _udpClient.Client.Bind(_localEP);
 }
        private void HardwareReadout()
        {
            try
            {
                //Creates a UdpClient for reading incoming data.
                UdpClient receivingUdpClient = new UdpClient(_poort);
                //Creates an IPEndPoint to record the IP Address and port number of the sender.
                // The IPEndPoint will allow you to read datagrams sent from any source.
                IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);

                while (true)
                {
                    byte[] receivedData = receivingUdpClient.Receive(ref RemoteIpEndPoint); // Blocking untill new data

                    if (NewData != null)
                    {
                        // Synchroon
                        NewData(receivedData);

                        // Asynchroon
                        //Task.Factory.StartNew(() => NewData(receivedData));
                    }

                }

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Receiver error");
            }
        }
Example #34
0
        private void Connect(IPEndPoint endPoint, int inputDeviceNumber, INetworkChatCodec codec)
        {
            waveIn = new WaveIn();
            waveIn.BufferMilliseconds = 50;
            waveIn.DeviceNumber = inputDeviceNumber;
            waveIn.WaveFormat = codec.RecordFormat;
            waveIn.DataAvailable += waveIn_DataAvailable;
            waveIn.StartRecording();

            udpSender = new UdpClient();
            udpListener = new UdpClient();

            // To allow us to talk to ourselves for test purposes:
            // http://stackoverflow.com/questions/687868/sending-and-receiving-udp-packets-between-two-programs-on-the-same-computer
            udpListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            udpListener.Client.Bind(endPoint);

            udpSender.Connect(endPoint);

            waveOut = new WaveOut();
            waveProvider = new BufferedWaveProvider(codec.RecordFormat);
            waveOut.Init(waveProvider);
            waveOut.Play();

            connected = true;
            var state = new ListenerThreadState { Codec = codec, EndPoint = endPoint };
            ThreadPool.QueueUserWorkItem(ListenerThread, state);
        }
        public UdpClientAdapter(UdpClient udpClient)
        {
            if (udpClient == null)
                throw new ArgumentNullException("udpClient");

            _udpClient = udpClient;
        }
Example #36
0
        private void Find()
        {
            try
            {
                Cursor = Cursors.WaitCursor;

                byte[] dnsQuery;
                byte[] dnsReply;
                UdpClient dnsClient = new UdpClient(textBoxDnsServer.Text, 53);

                dnsQuery = MakeQuery(DateTime.Now.Millisecond * 60,
                    textBoxDomain.Text);

                dnsClient.Send(dnsQuery, dnsQuery.Length);

                IPEndPoint ipEndPoint = null;
                dnsReply = dnsClient.Receive(ref ipEndPoint);

                richTextBoxMXServers.Text = MakeResponse(dnsReply, textBoxDomain.Text);
            }
            catch (SocketException ex)
            {
                MessageBox.Show(ex.Message, "Error",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                Cursor = Cursors.Default;
            }
        }
Example #37
0
        public static void StartListener(int port)
        {
            UdpClient client = new UdpClient();

                        client.ExclusiveAddressUse = false;
            IPEndPoint localEp = new IPEndPoint(IPAddress.Any, port);

                        client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                        client.ExclusiveAddressUse = false;

                        client.Client.Bind(localEp);

                        //IPAddress multicastaddress = IPAddress.Parse("239.0.0.222");
                        //client.JoinMulticastGroup(multicastaddress);

                        while (true)
                        {
                            Byte[] data = client.Receive(ref localEp);

                            string strData = Encoding.ASCII.GetString(data);

                eventH e = JsonConvert.DeserializeObject<eventH>(strData);
                e.handle();

                        }
        }
        private void BackgroundListener()
        {
            IPEndPoint bindingEndpoint = new IPEndPoint(IPAddress.Any, _endPoint.Port);
            using (UdpClient client = new UdpClient())
            {
                client.ExclusiveAddressUse = false;
                client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                client.Client.Bind(bindingEndpoint);
                client.JoinMulticastGroup(_endPoint.Address);

                bool keepRunning = true;
                while (keepRunning)
                {
                    try
                    {
                        IPEndPoint remote = new IPEndPoint(IPAddress.Any, _endPoint.Port);
                        byte[] buffer = client.Receive(ref remote);
                        lock (this)
                        {
                            DataReceived(this, new MulticastDataReceivedEventArgs(remote, buffer));
                        }
                    }
                    catch (ThreadAbortException)
                    {
                        keepRunning = false;
                        Thread.ResetAbort();
                    }
                }

                client.DropMulticastGroup(_endPoint.Address);
            }
        }
		void UdpEchoClientMethod(string[] args)
		{
			//Check for correct amount of arguments.
			if ((args.Length < 2) || (args.Length > 3))
				throw new ArgumentException("Parameters: <Server> <Word> [<Port>]");
			//Name/IPAddress
			string server = args[0];
			//Use port argument if supplied, otherwise default to 7
			int servPort = (args.Length == 3) ? Int32.Parse(args[2]) : 7;
			//Convert input string to an array of bytes.
			byte[] sendPacket = Encoding.ASCII.GetBytes(args[1]);
			//Create a UdpClient instance
			UdpClient client = new UdpClient();

			try
			{
				//Send the echo string(packet) to the specified host and port
				client.Send(sendPacket, sendPacket.Length, server, servPort);
				Console.WriteLine("Sent {0} bytes to the server...", sendPacket.Length);

				//This IPEndPoint instance will be populated with the remote sender's endpoint information after the Receive() call
				IPEndPoint remoteIPEndPoint = new IPEndPoint(IPAddress.Any, 0);

				//Attempt echo reply receive
				byte[] rcvPacket = client.Receive(ref remoteIPEndPoint);
				Console.WriteLine("Received {0} bytes from {1}: {2}", rcvPacket.Length, remoteIPEndPoint, Encoding.ASCII.GetString(rcvPacket, 0, rcvPacket.Length));
			}
			catch (SocketException se)
			{
				Console.WriteLine(se.ErrorCode + ": " + se.Message);
			}

			client.Close();
		}
Example #40
0
 public UdpClient(SysClient sysClient, IPEndPoint endpoint)
 {
     this.sysClient = sysClient;
     this.endpoint  = endpoint;
     listener       = new UdpObservable(sysClient);
     instream       = listener.SelectMany(SplitMessages);
 }
 public ServerUDPTunnel(ServerPlayer player)
 {
     // enstablish an Connection
     this.player = player;
     udp = new UdpClient(new IPEndPoint(IPAddress.Any, Server.instance.UDPStartPort + (int)player.id));
     udp.BeginReceive(onReceive, null);
 }
        public IPhoneSensor(int port)
        {
            recievingUdpClient = new UdpClient(port);
            RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);

            calibrateGPS(34.1064,-117.7119);
        }
Example #43
0
 public int Send(string sourceIp, string targetIp, int udpPort, TimeSpan delay, TimeSpan duration, List<string> source)
 {
     var start = DateTime.UtcNow;
     var localCounter = 0;
     using (var UC = new UdpClient(new IPEndPoint(IPAddress.Parse(sourceIp), 0)))
     {
         while (DateTime.UtcNow < start.Add(duration))
         {
             var txtMsg = source[localCounter % source.Count];
             var msg = Encoding.ASCII.GetBytes(txtMsg);
             var defMatch = SyslogParser.DefaultParser.Match(txtMsg);
             var privalMatch = defMatch.Groups["PRIVAL"].Value.Trim();
             var prival = int.Parse(privalMatch);
             var sent = new SimpleTxSyslog()
             {
                 Sev = (Severity)Enum.ToObject(typeof(Severity), prival & 0x7),
                 Fac = (Facility)Enum.ToObject(typeof(Facility), prival >> 3),
                 Message = defMatch.Groups["MESSAGE"].Value.Trim(),
             };
             this.SentList.Add(sent);
             UC.Send(msg, msg.Length, targetIp, udpPort);
             localCounter++;
             Thread.Sleep(delay);
         }
     }
     return localCounter;
 }
Example #44
0
		public static IObservable<UdpReceiveResult> CreateListener(IPAddress remoteAddress, int port)
		{
			if (remoteAddress == null) throw new ArgumentNullException(nameof(remoteAddress));
			if (port < 0 || port > 65535) throw new ArgumentOutOfRangeException(nameof(port), port, null);

			IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());

			var remoteIPBytes = remoteAddress.GetAddressBytes();
			var localAddress =
				host.AddressList.FirstOrDefault(ip =>
				ip.AddressFamily == remoteAddress.AddressFamily
				&& ip.GetAddressBytes().Take(3).SequenceEqual(remoteIPBytes.Take(3)));

			if (localAddress == null)
				throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.ExceptionMessages.Net_NoInterfaceInSameNetwork, remoteAddress, port));

			var localEndPoint = new IPEndPoint(localAddress, port);
			var remoteEndPoint = new IPEndPoint(remoteAddress, port);

			return Observable.Using(
				() =>
				{
					var client = new UdpClient { ExclusiveAddressUse = false };
					client.Client.Bind(localEndPoint);
					client.Connect(remoteEndPoint.Address, 0);
					return client;
				},
				client => Observable.While(() => client.Client.Connected, Observable.FromAsync(client.ReceiveAsync)));
		}
		public void TestConnectAsync_Success()
		{
			var endPoint = new IPEndPoint( IPAddress.Loopback, 57319 );

			var listener = new UdpClient( endPoint );
			try
			{
				using ( var target = new UdpClientTransportManager( new RpcClientConfiguration() ) )
				using ( var result = target.ConnectAsync( endPoint ) )
				{
					Assert.That( result.Wait( TimeSpan.FromSeconds( 1 ) ) );
					try
					{
						var transport = result.Result;
						Assert.That( transport.BoundSocket, Is.Not.Null );
						Assert.That( ( transport as UdpClientTransport ).RemoteEndPoint, Is.EqualTo( endPoint ) );
					}
					finally
					{
						result.Result.Dispose();
					}
				}
			}
			finally
			{
				listener.Close();
			}
		}
Example #46
0
        public UdpSocket(string Hostname, int Port, System.Action <byte[]> OnPacket, System.Action OnConnected, System.Action <string> OnCloseError)
        {
            //	todo: put some "unhandled" debug in these
            if (OnPacket == null)
            {
                OnPacket = (Packet) => { }
            }
            ;
            if (OnCloseError == null)
            {
                OnCloseError = (Error) => { }
            }
            ;
            if (OnConnected == null)
            {
                OnConnected = () => { }
            }
            ;

            this.OnPacket     = OnPacket;
            this.OnCloseError = OnCloseError;

            //	if constructor doesn't throw, we're connected
            //EndPoint = GetEndPoint(Hostname, Port);
            //Socket = new UdpClient(EndPoint);
            EndPoint = new IPEndPoint(IPAddress.Any, 0);
            Socket   = new UdpClient(Hostname, Port);
            OnConnected.Invoke();
            StartRecv();
        }
Example #47
0
        public UDPProtocol(int localPort)
        {
            this.localPort = localPort;

            udpClient = new System.Net.Sockets.UdpClient(localPort);
            udpClient.AllowNatTraversal(true);
            this.serverIPEndPoint = new IPEndPoint(IPAddress.Parse(serverIP), serverPort);
        }
Example #48
0
 /// <summary>
 /// Connect to any remote machine that wants to send to the given local port.
 /// </summary>
 public void Connect(IPEndPoint localEndPoint)
 {
     this.localEndPoint = localEndPoint;
     udp = new System.Net.Sockets.UdpClient(localEndPoint);
     udp.Client.ReceiveBufferSize = 1000000;
     receivingPending             = true;
     udp.BeginReceive(new AsyncCallback(OnPacketReceived), this);
 }
Example #49
0
        private void InitClient()
        {
            _client = new System.Net.Sockets.UdpClient(11000);
            _client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12000));

            //_receiveClient = new System.Net.Sockets.UdpClient(11000);
            receivingUdpClient = new System.Net.Sockets.UdpClient(12000);
        }
Example #50
0
 public void Close()
 {
     if (udp != null)
     {
         udp.Close();
         udp = null;
     }
 }
Example #51
0
 public UdpClient(int localPort)
 {
     //_client = new System.Net.Sockets.UdpClient(new IPEndPoint(IPAddress.Any, 48899))
     _client = new System.Net.Sockets.UdpClient(localPort);
     {
         //EnableBroadcast = true,
         //DontFragment = true,
     };
 }
Example #52
0
 public UDPClient(Int32 port, bool ignoreUnknown)
 {
     this.ignoreUnknown = ignoreUnknown;
     this.rawClient     = new System.Net.Sockets.UdpClient(port);
     this.output        = new BlockingCollection <Packet>();
     this.running       = true;
     this.thread        = new Thread(this.ListenThread);
     this.thread.Start();
 }
Example #53
0
        private void CreateUdpClient()
        {
            _udpClient = new UdpClient();
            uint IOC_IN            = 0x80000000;
            uint IOC_VENDOR        = 0x18000000;
            uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;

            _ = _udpClient.Client.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
        }
Example #54
0
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="strLocalIP">本地IP</param>
        /// <param name="localPort">本地端口</param>
        /// <param name="remoteIP">服务器IP</param>
        /// <param name="remotePort">服务器端口</param>
        /// <param name="vModForm">接收数据修改显示事件</param>
        /// <param name="vServerOnLine">修改服务器在线或否的事件</param>
        public UdpClient(string strLocalIP, int localPort,
                         string remoteIP, int remotePort, int vWorkStation,
                         Action <IMsg> vModForm,
                         Action <string, Color> vServerOnLine
                         )
        {
            if (Ins != null)
            {
                throw new Exception("对象已经存在");
            }
            //g_m = em;
            //FrmMain frmMain = g_m as FrmMain;
            E_ModForm      = vModForm;
            E_ServerOnLine = vServerOnLine;
            LocMsg         = new MsgBase()
            {
                DaType      = "BS",
                LocalIP     = strLocalIP,
                LocalPort   = localPort,
                RemoteIP    = remoteIP,
                RemotePort  = remotePort,
                WorkStation = vWorkStation
            };
            Frame.Ins.FrmMsg = LocMsg;

            this.localPort = localPort;
            remoteEP       = new IPEndPoint(IPAddress.Parse(remoteIP), remotePort);
            lock (this)
            {
                try
                {
                    udpSend = new System.Net.Sockets.UdpClient(localPort);
                }
                catch (Exception ex)
                {
                    throw ex;
                    //MessageBox.Show("本地端口" + localPort.ToString() + "已被占用!", "提示", MessageBoxButtons.OK);
                    //if (frmMain.IsHandleCreated)
                    //{
                    //    Environment.Exit(0);
                    //}
                    //return;
                }
            }
            udpSendState = new UdpState
            {
                ipEndPoint = remoteEP,
                udpClient  = udpSend
            };
            udpReceiveState = new UdpState
            {
                ipEndPoint = remoteEP,
                udpClient  = udpSend
            };
            readCallback    = new AsyncCallback(SendCallback);
            receiveCallback = new AsyncCallback(ReceiveCallback);
        }
Example #55
0
        //打开socket通信
        private void btnConnect_Click(object sender, EventArgs e)
        {
            System.Net.IPAddress ipaddr = null;
            if (!System.Net.IPAddress.TryParse(this.tbIP.Text, out ipaddr))
            {
                MessageBox.Show("请正确填写IP地址!");
                return;
            }

            int iPort = 0;

            if (!int.TryParse(this.tbPort.Text, out iPort) || iPort <= 0)
            {
                MessageBox.Show("请正确填写端口!");
                return;
            }

            _ipaddrDes = new System.Net.IPEndPoint(ipaddr, iPort);

            if (_udp != null)
            {
                _udp.Close();
                _udp = null;
            }

            _udp = new UdpClient(_portListen);

            try
            {
                _udp.Connect(_ipaddrDes);
            }
            catch (System.ObjectDisposedException)
            {
                MessageBox.Show("System.Net.Sockets.UdpClient 已关闭");
                return;
            }
            catch (System.ArgumentOutOfRangeException)
            {
                MessageBox.Show("port 不在 System.Net.IPEndPoint.MinPort 和 System.Net.IPEndPoint.MaxPort 之间");
                return;
            }
            catch (System.Net.Sockets.SocketException ex)
            {
                MessageBox.Show("试图访问套接字时发生错误:" + ex.Message);
                return;
            }
            catch (Exception ex)
            {
                MessageBox.Show("未知类型错误:" + ex.Message);
                return;
            }
            Program.SetAppSettingValue("DefaultIP", this.tbIP.Text);
            Program.SetAppSettingValue("DefaultPortNo", this.tbPort.Text);

            this.btnDisconnect.Enabled = true;
            this.btnConnect.Enabled    = false;
        }
Example #56
0
            /// <summary>
            /// broadcast a message to others
            /// </summary>
            /// <param name="msg"></param>
            static public void Broadcast(string msg, int UDPPort)
            {
                var epGroup = new System.Net.IPEndPoint(System.Net.IPAddress.Parse("224.0.0.2"), UDPPort);
                var buffer  = System.Text.Encoding.UTF8.GetBytes(msg);

                System.Net.Sockets.UdpClient UdpClient = new System.Net.Sockets.UdpClient(1019);
                UdpClient.Send(buffer, buffer.Length, epGroup);
                UdpClient.Close();
            }
Example #57
0
            /// <summary>
            /// broadcast a message to others
            /// </summary>
            /// <param name="msg"></param>
            static public void Broadcast(string msg)
            {
                var epGroup = new System.Net.IPEndPoint(GroupIP, 1020);
                var buffer  = System.Text.Encoding.UTF8.GetBytes(msg);

                UdpClient = new System.Net.Sockets.UdpClient(1019);
                UdpClient.Send(buffer, buffer.Length, epGroup);
                UdpClient.Close();
            }
Example #58
0
 public UdpServer(int tcpPort, int updPort, string message)
 {
     _listenPort       = updPort;
     _groupAddresses   = new IPEndPoint(IPAddress.Any, _listenPort);
     _udpServer        = new System.Net.Sockets.UdpClient(_listenPort);
     _tcpPort          = tcpPort;
     _broadcastMessage = message;
     _mainLoop         = new Thread(UdpListen);
 }
Example #59
-1
        public async Task<IEnumerable<Server>> GetServers(
            MasterServerRegion region = MasterServerRegion.All,
            params MasterServerFilter[] masterServerFilters)
        {
            var servers = new List<Server>();

            using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
            {
                client.Connect(_steamSteamIpAddress, _steamSteamPort);

                string thisServer = null;
                while (thisServer != FIRST_AND_LAST_SERVER)
                {
                    var requestPacket = CreateRequestPacket(thisServer ?? FIRST_AND_LAST_SERVER, region, masterServerFilters);
                    await client.SendAsync(requestPacket, requestPacket.Length);
                    var response = await client.ReceiveAsync();
                    var responseData = response.Buffer.ToList();
                    for (int i = HEADER_BYTES_LENGTH; i < responseData.Count; i++)
                    {
                        var ip = string.Join(".", responseData.GetRange(i, 4).ToArray());
                        int port = responseData[i + 4] << 8 | responseData[i + 5];
                        thisServer = string.Format("{0}:{1}", ip, port);
                        if (thisServer != FIRST_AND_LAST_SERVER)
                        {
                            servers.Add(new Server(new IPEndPoint(IPAddress.Parse(ip), port)));
                        }
                        i += 5;
                    }
                }
            }

            return servers;
        }
        static void Main(string[] args)
        {
            System.Net.Sockets.UdpClient sock = new System.Net.Sockets.UdpClient();
            IPEndPoint iep = new IPEndPoint(IPAddress.Parse("129.241.187.44"), 20004);

            Console.WriteLine("Enter message");
            string userinput = Console.ReadLine();
            byte[] data = Encoding.ASCII.GetBytes(userinput);
            sock.Send(data, data.Length, iep);
            sock.Close();

            Console.WriteLine("Message sent.");



            System.Net.Sockets.UdpClient server = new System.Net.Sockets.UdpClient(20004);
            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            byte[] recvdata = new byte[1024];
            recvdata = server.Receive(ref sender);
            server.Close();
            string stringData = Encoding.ASCII.GetString(recvdata, 0, recvdata.Length);
            Console.WriteLine("Response from " + sender.Address + Environment.NewLine + "Message: " + stringData);
            Console.ReadLine();

        }