// receive thread
    private void ReceiveData()
    {
        client = new UdpClient();

        IPEndPoint localEp = new IPEndPoint(IPAddress.Any, port);
        client.Client.Bind(localEp);

        client.JoinMulticastGroup(IPAddress.Parse(MULTICAST_ADDR));
        while (true)
        {
            try
            {
                byte[] data = client.Receive(ref localEp);
                string text = Encoding.UTF8.GetString(data);
                string[] message = text.Split(',');
                Vector3 result = new Vector3(float.Parse(message[0]), float.Parse(message[1]), float.Parse(message[2]));

                print(">> " + result);

                lastReceivedUDPPacket = result;
            }
            catch (Exception err)
            {
                print(err.ToString());
            }
        }
    }
Exemple #2
3
    public static void Main()
    {
        byte[] data = new byte[1024];
          	string input, stringData;
          	UdpClient server = new UdpClient("127.0.0.1", 9877);

        IPEndPoint sender = new IPEndPoint(IPAddress.Any, 9876);

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

        data = server.Receive(ref sender);

        Console.WriteLine("Message received from {0}:", sender.ToString());
        stringData = Encoding.ASCII.GetString(data, 0, data.Length);
        Console.WriteLine(stringData);

        while(true){
            input = Console.ReadLine();
            if (input == "exit")
                break;

                server.Send(Encoding.ASCII.GetBytes(input), input.Length);
             	data = server.Receive(ref sender);
        }
        Console.WriteLine("Stopping client");
        server.Close();
    }
Exemple #3
1
    public static void Main()
    {
        byte[] data = new byte[1024];
          IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 9876);
          UdpClient newsock = new UdpClient(ipep);

          Console.WriteLine("Waiting for a client...");

          IPEndPoint sender = new IPEndPoint(IPAddress.Any, 9877);

          data = newsock.Receive(ref sender);

          Console.WriteLine("Message received from {0}:", sender.ToString());
          Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));

          string msg = Encoding.ASCII.GetString(data, 0, data.Length);
          data = Encoding.ASCII.GetBytes(msg);
          newsock.Send(data, data.Length, sender);

          while(true){
         data = newsock.Receive(ref sender);

         Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));
         newsock.Send(data, data.Length, sender);
          }
    }
Exemple #4
0
   public static void Main()
   {
      byte[] data = new byte[1024];
      string input, stringData;
      UdpClient udpClient = new UdpClient("127.0.0.1", 9999);

      IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);

      string welcome = "Hello";
      data = Encoding.ASCII.GetBytes(welcome);
      udpClient.Send(data, data.Length);

      data = udpClient.Receive(ref sender);

      Console.WriteLine("Message received from {0}:", sender.ToString());
      stringData = Encoding.ASCII.GetString(data, 0, data.Length);
      Console.WriteLine(stringData);

      while(true)
      {
         input = Console.ReadLine();
         udpClient.Send(Encoding.ASCII.GetBytes(input), input.Length);
         data = udpClient.Receive(ref sender);
         stringData = Encoding.ASCII.GetString(data, 0, data.Length);
         Console.WriteLine(stringData);
      }
      udpClient.Close();
   }
    public void StartListener()
    {
        bool done = false;

        UdpClient listener = new UdpClient(listenPort);
        IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, listenPort);

        try
        {
            while (!done)
            {
                Console.WriteLine("Waiting for broadcast");
                byte[] bytes = listener.Receive( ref groupEP);

                Console.WriteLine("Received broadcast from {0} :\n {1}\n",
                    groupEP.ToString(),
                    Encoding.ASCII.GetString(bytes,0,bytes.Length));
            }

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
        finally
        {
            listener.Close();
        }
    }
Exemple #6
0
 public static int Main()
 {
     bool done = false;
     UdpClient listener = new UdpClient(listenPort);
     IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, listenPort);
     string received_data;
     byte[] receive_byte_array;
     try
     {
         while (!done)
         {
             Console.WriteLine("Waiting for broadcast");
             // this is the line of code that receives the broadcase message.
             // It calls the receive function from the object listener (class UdpClient)
             // It passes to listener the end point groupEP.
             // It puts the data from the broadcast message into the byte array
             // named received_byte_array.
             // I don't know why this uses the class UdpClient and IPEndPoint like this.
             // Contrast this with the talker code. It does not pass by reference.
             // Note that this is a synchronous or blocking call.
             receive_byte_array = listener.Receive(ref groupEP);
             Console.WriteLine("Received a broadcast from {0}", groupEP.ToString());
             received_data = Encoding.ASCII.GetString(receive_byte_array, 0, receive_byte_array.Length);
             Console.WriteLine("data follows \n{0}\n\n", received_data);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.ToString());
     }
     listener.Close();
     return 0;
 }
Exemple #7
0
    public static void Main()
    {
        string addr = "127.0.0.1";
        int port = 7980;
        short cmd = 1;
        short seq = 0;
        string msg = "Hello";
        byte[] payload = Encoding.ASCII.GetBytes(msg);
        byte[] packet = Packet.Create(cmd, seq, payload);

        UdpClient udp = new UdpClient();
        var ip = IPAddress.Parse(addr);
        IPEndPoint ep = new IPEndPoint(ip, port);
        udp.Connect(ep);

        // send
        udp.Send(packet, packet.Length);

        // receive
        bool done = false;
        while (!done) {
            if (udp.Available <= 0) {
                IPEndPoint ep2 = new IPEndPoint(0, 0);
                byte[] packet2 = udp.Receive(ref ep2);

                Console.WriteLine("packet size: {0}", packet2.Length);

                Dictionary<string, object> parsed = Packet.Parse(packet2);
                foreach (KeyValuePair<string, object> item in parsed) {
                    Console.WriteLine("Received:{0} = {1}", item.Key, item.Value);
                }
                done = true;
            }
        }
    }
Exemple #8
0
        private bool CheckUsb()
        {
            try
            {
                // Если буфер приема не пустой, очищаем
                if (_resiver != null && _resiver?.Available > 0)
                {
                    _resiver.Receive(ref _remoteIpEndPoint);
                }

                _sender.Send(_comGetStatus, _comGetStatus.Length, _endPoint);
                var resp = _resiver?.Receive(ref _remoteIpEndPoint);
                //Проверка доступности ОЕД
                if (resp != null && resp[0] == 10 && resp[2] == 1 && resp[8] == 1)
                {
                    Dispatcher.Invoke(() =>
                    {
                        BtnIndicUsb.Background = Brushes.GreenYellow;
                    });
                    return(true);
                }
                AddToOperationsPerfomed("USB не доступен.");
            }
            catch (SocketException)
            {
                AddToOperationsPerfomed("STM не вернул статус USB соединения. TimeOut.");
            }
            Dispatcher.Invoke(() =>
            {
                BtnIndicUsb.Background = Brushes.OrangeRed;
                BtnIndicOed.Background = Brushes.OrangeRed;
            });
            return(false);
        }
Exemple #9
0
    private static void StartListener()
    {
        //Initiate UDP server
        Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        UdpClient listener = new UdpClient(ListenPort);
        IPEndPoint groupEp = new IPEndPoint(IPAddress.Any,ListenPort);
        IPEndPoint responseEp;
        string receivedCommand;

        try
        {
            while (true)
            {
                //Wait for incoming command
                Console.WriteLine("Waiting for command");
                byte[] bytes = listener.Receive( ref groupEp);
                receivedCommand = Encoding.ASCII.GetString(bytes,0,bytes.Length);
                Console.WriteLine("Received command: " + receivedCommand + " from " + groupEp.Address);

                //Send matching response
                responseEp = new IPEndPoint(groupEp.Address, ListenPort);
                if (receivedCommand == "U" || receivedCommand ==  "u")
                {
                    using (StreamReader sr = new StreamReader ("/proc/uptime"))
                    {
                        String line = sr.ReadToEnd();
                        Console.WriteLine("Sending uptime: " + line);

                        byte[] sendbuf = Encoding.ASCII.GetBytes(line);
                        s.SendTo(sendbuf, responseEp);
                    }
                }
                else if(receivedCommand == "L" || receivedCommand ==  "l")
                {
                    using (StreamReader sr = new StreamReader ("/proc/loadavg"))
                    {
                        String line = sr.ReadToEnd();
                        Console.WriteLine("Sending load average: " + line);

                        byte[] sendbuf = Encoding.ASCII.GetBytes(line);
                        s.SendTo(sendbuf, responseEp);
                    }
                }
                else
                {
                    Console.WriteLine("Command " + receivedCommand + " not found\n");
                    byte[] sendbuf = Encoding.ASCII.GetBytes("Input not recognized, please try again!");
                    s.SendTo(sendbuf, responseEp);
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
        finally
        {
            listener.Close();
        }
    }
Exemple #10
0
        static void Main()
        {
            //データを送信するリモートホストとポート番号
            string    remoteHost    = "127.0.0.1";
            IPAddress remoteAddress = IPAddress.Parse(remoteHost);
            int       remotePort    = 2002;

            UdpClient udpClient = new UdpClient();

            if (null != udpClient)
            {
                //ビルドのクエリを投げる
                string sendMsg = "test";
                byte[] buff    = Encoding.UTF8.GetBytes(sendMsg);
                udpClient?.Send(buff, buff.Length, remoteHost, remotePort);

                //戻り値取得
                IPEndPoint remoteEP = null;
                buff = udpClient?.Receive(ref remoteEP);
                string rcvMsg = Encoding.UTF8.GetString(buff);
                int    rtv    = int.Parse(rcvMsg);

                Console.WriteLine(rtv);

                //UdpClientを閉じる
                udpClient?.Close();
            }


            Console.ReadLine();
        }
	private void Listen()
	{
		System.Random myRandom = new System.Random();
		udpClient = new UdpClient(7272, AddressFamily.InterNetwork);

		var endPoint = default(IPEndPoint);

		byte[] bytes;

		while (m_shouldRun)
		{
			try
			{
				bytes = udpClient.Receive(ref endPoint);
				if (bytes == null || bytes.Length == 0)
					break;

				int offset = 0;
				lock (m_threadLock)
				{
					m_head = FromOculusToUnity(Vector3FromBytes(bytes, ref offset));
					m_rHand = FromOculusToUnity(Vector3FromBytes(bytes, ref offset));
					//m_rHandRotation = Vector4FromBytes(bytes, ref offset);
					m_lHand = FromOculusToUnity(Vector3FromBytes(bytes, ref offset));
					//m_lHandRotation = Vector4FromBytes(bytes, ref offset);
					m_rightClosed = BoolFromBytes(bytes, ref offset);
				}
			} catch (ThreadInterruptedException)
			{
				// Empty on purpose
			}
		}
	}
	private void ReceiveData(){

		client = new UdpClient(port); //Binds udp client to random port
		while (true)
		{

			try
			{
				
				IPEndPoint IPEndPoint = new IPEndPoint(IPAddress.Any, 0);
				byte[] data = client.Receive(ref IPEndPoint);

				string text = Encoding.UTF8.GetString(data);

				if(log){
					Debug.Log(text);
				}

				lock(receivedUDPPackets){
					receivedUDPPackets.Add(text);
				}
			}
			catch (Exception err)
			{
				print(err.ToString());
			}
		}
	}
Exemple #13
0
 static void ThreadFuncReceive()
 {
     try
     {
         while (true)
         {
             //подключение к локальному хосту
             UdpClient uClient = new UdpClient(LocalPort);
             IPEndPoint ipEnd = null;
             //получание дейтаграммы
             byte[] responce = uClient.Receive(ref ipEnd);
             //преобразование в строку
             string strResult = Encoding.Unicode.GetString(responce);
             Console.ForegroundColor = ConsoleColor.Green;
             //вывод на экран
             Console.WriteLine(strResult);
             Console.ForegroundColor = ConsoleColor.Red;
             uClient.Close();
         }
     }
     catch (SocketException sockEx)
     {
         Console.WriteLine("Ошибка сокета: " + sockEx.Message);
     }
     catch (Exception ex)
     {
         Console.WriteLine("Ошибка : " + ex.Message);
     }
 }
Exemple #14
0
 private static void StartListener()
 {
     bool done = false;
     IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, listenPort);
     UdpClient listener = new UdpClient(groupEP);
     Log.Notice("Listener", "Waiting for broadcast");
     try
     {
         while (!done)
         {
             byte[] bytes = listener.Receive(ref groupEP);
             Log.Info("Listener", "Client " + groupEP.ToString() + " is trying to connect");
             listener.Connect(groupEP);
             Log.Succes("Listener", "Listener connected to client " + groupEP.ToString());
             done = true;
             //TODO - rest of district server connecting
         }
     }
     catch (Exception e)
     {
         FrameWork.Logger.Log.Error("Listener", e.ToString());
     }
     finally
     {
         listener.Close();
     }
 }
    void RecieveDatagram()
    {
        UdpClient receivingUdpClient = new UdpClient ( 35143 );
        IPEndPoint RemoteIpEndPoint = new IPEndPoint ( IPAddress.Any, 0 );

        while ( true )
        {

            try {

                Byte[] receiveBytes = receivingUdpClient.Receive ( ref RemoteIpEndPoint );
                returnData = Encoding.Unicode.GetString ( receiveBytes );

                if ( returnData.Substring ( 0, 17 ) == "[2CatStudios:UMP]" )
                {

                    UnityEngine.Debug.Log ( "Recieved '" + returnData.ToString () + "' This message was sent on " + RemoteIpEndPoint.Address.ToString() + " via the port " + RemoteIpEndPoint.Port.ToString ());
                    returnData = returnData.Substring ( 17 );
                } else {

                    UnityEngine.Debug.Log ( "Data was recieved, but it was not expected." );
                }
            }
            catch ( Exception e )
            {

                UnityEngine.Debug.Log ( e.ToString ());
                returnData = e.ToString ();
            }
        }
    }
    void procComm()
    {
        port = getPort();
        string ipadr = getIpadr ();

        client = new UdpClient ();

        // send
        string sendstr = IFmsg.text + System.Environment.NewLine;
        byte[] data = ASCIIEncoding.ASCII.GetBytes (sendstr);
        client.Send (data, data.Length, ipadr, port);

        // receive
        client.Client.ReceiveTimeout = 2000; // msec
        IPEndPoint remoteIP = new IPEndPoint(IPAddress.Any, 0);
        lastRcvd = "";
        try {
            data = client.Receive (ref remoteIP);
            if (data.Length > 0) {
                string text = Encoding.ASCII.GetString (data);
                lastRcvd = text;
            }
        } catch (Exception err) {
        }

        client.Close ();
    }
Exemple #17
0
	private  void ReceiveData()
	{
		client = new UdpClient(8000);
		while (running)
		{			
			try
			{
				IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
				byte[] data = client.Receive(ref anyIP);				
				
				string text = Encoding.UTF8.GetString(data);
				Debug.Log("Input "+text);
				string[] info = text.Split(':');
				
				inputText = text;
				
				if(info[0].Equals("speed")){
					speed= info[1];
				}
				if(info[0].Equals("turn")){
					axis= info[1];
				}
				
				
			}
			catch (Exception err)
			{
				running =false;
				print(err.ToString());
			}
		}
	}
Exemple #18
0
	private static void WontDie ()
	{
		while (true) {
			IPEndPoint endpoint = new IPEndPoint (IPAddress.Loopback, 1900);
			UdpClient s = new UdpClient ();
			byte [] buffer = new byte [1024];
			s.Send (buffer, buffer.Length, endpoint);
			s.Receive (ref endpoint);
		}
	}
    void DoRelay()
    {
        UdpClient client = new UdpClient (setPort);
        client.Client.ReceiveTimeout = 300; // msec
        client.Client.Blocking = false;

        int portToReturn = 31415; // is set dummy value at first
        while (ToggleComm.isOn) {
            try {
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = client.Receive(ref anyIP);
                string text = Encoding.ASCII.GetString(data);

                if (text.Length == 0) {
                    Thread.Sleep(20);
                    continue;
                }

                if (text.Contains(kExportCommand)) {
                    exportData(ref client, ref anyIP);
                    continue;
                }

                string fromIP = anyIP.Address.ToString();
                int fromPort = anyIP.Port;

                // send to the other
                if (fromIP.Equals(ipadr1)) {
                    portToReturn = fromPort; // store the port used in the "else" clause

                    list_comm_time.Add(System.DateTime.Now);
                    list_comm_string.Add("tx," + text);

                    client.Send(data, data.Length, ipadr2, setPort);
                    DebugPrintComm("1 ", fromIP, fromPort, ipadr2, setPort);
                } else {
                    // delay before relay
                    Thread.Sleep(delay_msec);

                    list_comm_time.Add(System.DateTime.Now);
                    list_comm_string.Add("rx," + text);

                    client.Send(data, data.Length, ipadr1, portToReturn);
                    DebugPrintComm("2 ", fromIP, fromPort, ipadr1, portToReturn);
                }
            }
            catch (Exception err) {

            }
            // without this sleep, on android, the app will freeze at Unity splash screen
            Thread.Sleep(200);
        }
        client.Close ();
    }
	void ReceiveData(){
		Debug.Log ("Thread Started");
		IPEndPoint inAddrAny = new IPEndPoint(IPAddress.Any, 0);
		client = new UdpClient (port);

		int byteCount = 0;

		byte[] newestValidMessage = new byte[messageLen];

		while (true) {
			byte[] received = client.Receive(ref inAddrAny);
			Debug.Log("Got " + received.Length + " bytes");
			if(received.Length>=messageLen-byteCount){
				//there is enough new information to complete an update
				int bytesLeft = messageLen-byteCount;
				if(received.Length-bytesLeft>messageLen){
					//entirely new message contained in latest receive
					int remainder = (received.Length-bytesLeft)%messageLen;

					for(int i = received.Length-1-remainder;i>received.Length-1-remainder-messageLen;i--){
						newestValidMessage[i%messageLen] = received[i];
					}

					UpdateHands(newestValidMessage);

					for(int i =received.Length-1-remainder;i<received.Length;i++){
						newestValidMessage[i-received.Length+1+remainder] = received[i];
					}

				}
				else{
					for(int i=byteCount;i<messageLen;i++){
						newestValidMessage[i] = received[i-byteCount];
					}
					UpdateHands(newestValidMessage);
					for(int i=messageLen;i<received.Length;i++){
						newestValidMessage[i-messageLen] = received[i];
					}
					byteCount = (byteCount+received.Length)%messageLen;
				}
			}

			else{
				//there is not enough information to complete an update
				for(int i=byteCount;i<messageLen;i++){
					newestValidMessage[i] = received[i-byteCount];
				}
				byteCount+=received.Length;
			}

		}

	}
Exemple #21
0
	public static void Main ()
	{
		var ip = IPAddress.Parse ("239.255.255.250");
		while (true) {
			UdpClient udp = new UdpClient (3802);
			udp.JoinMulticastGroup (ip, 1);
			IPEndPoint dummy = null;
			udp.Receive (ref dummy);
			Console.WriteLine ("Received");
			udp.DropMulticastGroup (ip);
			udp.Close ();
		}
	}
Exemple #22
0
    private void ConnectUDP()
    {
        print("Connect UDP");
        unityIPEP = new IPEndPoint(Client.IP, 64582);
        kinectIPEP = new IPEndPoint(IPAddress.Any, 0);
        socket = new UdpClient(unityIPEP);

        print("Waiting for Initial Message");

        udpMessage = socket.Receive(ref kinectIPEP);
        print("Initial Message Received");
        connected = true;
    }
        public Message MessageAvailable()
        {
            Log.InfoFormat(@"Packet available");
            var ep = new IPEndPoint(IPAddress.Any, 0);

            byte[] receiveBytes = _udpClient?.Receive(ref ep);
            Log.Debug($"Bytes received: {FormatBytesForDisplay(receiveBytes)}");
            _readWrite.DecodeMessage(receiveBytes);
            Message result = _readWrite.targetMessage;

            result.fromAddress = ep;
            if (result != null)
            {
                Log.InfoFormat($"Received type: '{result.thisMessageType}' " +
                               $" content: '{result.messageBody}' from: {result.fromAddress}");
            }
            else
            {
                Log.Warn(@"Data received, but could not be decoded");
            }
            return(result);
        }
 // receive thread
 private void ReceiveData()
 {
     client = new UdpClient(port);
     while (true) {
         try {
             IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
             byte[] data = client.Receive(ref anyIP);
             string text = Encoding.UTF8.GetString(data);
             lastReceivedUDPPacket=text;
             allReceivedUDPPackets=allReceivedUDPPackets+text;
         }catch (Exception err) {
         }
     }
 }
    private void ReceiveData()
    {
        client = new UdpClient(port);
        while (m_keepRunning)
        {
            try
            {

                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);

                byte[] data = client.Receive(ref anyIP);

 

                // Bytes mit der UTF8-Kodierung in das Textformat kodieren.

                string text = Encoding.UTF8.GetString(data);
				
				Debug.Log(text);
				
				string[] words = text.Split(' ');

 				
				Quaternion q = new Quaternion(float.Parse(words[12]),
				                              float.Parse(words[13]),
				                              float.Parse(words[14]),
				                              float.Parse(words[15]));
				Vector3 t = new Vector3(float.Parse(words[18]),
				                        float.Parse(words[19]),
				                        float.Parse(words[20]));

                m_newData = new Pose();
                UbiMeasurementUtils.coordsysemChange(t, ref m_newData.pos);
                UbiMeasurementUtils.coordsysemChange(q, ref m_newData.rot);

            }

            catch (Exception err)

            {

                Debug.Log(err.ToString());

            }

        }
		client.Close();

    }
Exemple #26
0
    protected override void Execute()
    {
        UdpClient server = null;

        server = new UdpClient(8080) { DontFragment = true };
        IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, 8080);
        for(;;){
            byte[] receive = server.Receive(ref endPoint);
            retrievedPacket(receive.Length, receive);

            if(terminate) break;
        }

        logger.Log("Thread Stop");
    }
Exemple #27
0
        public Message Receive(int timeout)
        {
            Log.Debug("Entering Receive");

            Message result = null;

            try
            {
                // Wait for some data to become available
                while (CommunicationsEnabled && _udpClient?.Available <= 0 && timeout > 0)
                {
                    Thread.Sleep(10);
                    timeout -= 10;
                }

                // If there is data receive and communications are enabled, then read that data
                if (CommunicationsEnabled && _udpClient?.Available > 0)
                {
                    Log.InfoFormat(@"Packet available");
                    var    ep           = new IPEndPoint(IPAddress.Any, 0);
                    byte[] receiveBytes = _udpClient?.Receive(ref ep);
                    Log.Debug($"Bytes received: {FormatBytesForDisplay(receiveBytes)}");
                    result = Message.Create(receiveBytes);
                    if (result != null)
                    {
                        result.SenderEndPoint = ep;
                        Log.InfoFormat($"Received {result} from {ep}");
                    }
                    else
                    {
                        Log.Warn(@"Data received, but could not be decoded");
                    }
                }
            }
            catch (SocketException err)
            {
                if (err.SocketErrorCode != SocketError.TimedOut && err.SocketErrorCode != SocketError.ConnectionReset)
                {
                    Log.ErrorFormat($"Socket error: {err.SocketErrorCode}, {err.Message}");
                }
            }
            catch (Exception err)
            {
                Log.ErrorFormat($"Unexpected expection while receiving datagram: {err} ");
            }
            Log.Debug("Leaving Receive");
            return(result);
        }
Exemple #28
0
        static void Main()
        {
            //データを送信するリモートホストとポート番号
            string    remoteHost    = "127.0.0.1";
            IPAddress remoteAddress = IPAddress.Parse(remoteHost);
            int       remotePort    = 2002;

            UdpClient udpClient = new UdpClient();

            if (null != udpClient)
            {
                //ビルドのクエリを投げる
                {
                    string sendMsg = "test";
                    byte[] buff    = Encoding.UTF8.GetBytes(sendMsg);
                    udpClient?.Send(buff, buff.Length, remoteHost, remotePort);
                }

                //戻り値取得
                IPEndPoint remoteEP = null;
                udpClient.Client.ReceiveTimeout = 10000;
                int rtv = -1;
                {
                    byte[] buff = null;
                    try
                    {
                        buff = udpClient?.Receive(ref remoteEP);
                    }
                    catch (SocketException e)
                    {
                    }

                    if (null != buff)
                    {
                        string rcvMsg = Encoding.UTF8.GetString(buff);
                        int.TryParse(rcvMsg, out rtv);
                    }
                }

                Console.WriteLine(rtv);

                //UdpClientを閉じる
                udpClient?.Close();
            }


            Console.ReadLine();
        }
Exemple #29
0
    private void ReceiveData()
    {
        client = new UdpClient (port);
        while (true) {
            try{
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Parse(address), port);
                byte[] data = client.Receive(ref anyIP);

                string text = Encoding.UTF8.GetString(data);
                //print (">> " + text);
                lastReceivedUDPPacket=text;
                allReceivedUDPPackets=allReceivedUDPPackets+text;
                string[] numberStrs = text.Split(' ');
                string debugNumbers = "";
                for (int i = 0; i < numberStrs.Length; ++i)
                {
                    debugNumbers += numberStrs[i] + ", ";
                }

                print (debugNumbers);

                cameraPos.x = float.Parse(numberStrs[0]);
                cameraPos.y = float.Parse (numberStrs[1]);
                cameraPos.z = float.Parse (numberStrs[2]);

                rotationAngles.x = float.Parse (numberStrs[3]);
                rotationAngles.y = float.Parse (numberStrs[4]);
                rotationAngles.z = float.Parse (numberStrs[5]);

                mouthPos.x = float.Parse (numberStrs[6]);
                mouthPos.y = float.Parse (numberStrs[7]);
                mouthPos.z = float.Parse (numberStrs[8]);

                mouthRatio = float.Parse (numberStrs[9]);

                float faceRectangleX = float.Parse (numberStrs[10]) * Screen.width;
                float faceRectangleY = float.Parse(numberStrs[11]) * Screen.height;
                float faceRectangleWidth = float.Parse (numberStrs[12]) * Screen.width;
                float faceRectangleHeight = float.Parse(numberStrs[13]) * Screen.height;
                faceRectangle = new Rect(faceRectangleX, faceRectangleY, faceRectangleWidth, faceRectangleHeight);

                //print (faceRectangle);

            }catch(Exception e){
                print (e.ToString());
            }
        }
    }
        protected virtual void ReceiveUpdateLoop()
        {
            while (UpdateClient != null)
            {
                Thread.Sleep(0);

                IPEndPoint known  = UpdateEndPoint ?? ManagementEndPoint;
                IPEndPoint remote = known;
                byte[]     data   = null;
                try {
                    // Let's just hope that we always receive a full frame...
                    // Console.WriteLine("Starting receive update");
                    data = UpdateClient?.Receive(ref remote);
                    // Console.WriteLine($"Finished receive update from {remote}: {data.ToHexadecimalString()}");
                } catch (Exception e) {
                    Logger.Log(LogLevel.Warn, "ghostnet-con", "Failed receiving update frame");
                    LogContext(LogLevel.Warn);
                    e.LogDetailed();
                    if (DisposeOnFailure)
                    {
                        Dispose();
                        return;
                    }
                }
                if (known != null && !remote.Address.Equals(known.Address))
                {
                    Logger.Log(LogLevel.Warn, "ghostnet-con", $"Received update data from unknown remote {remote}: {data.ToHexadecimalString()}");
                    continue;
                }

                try {
                    using (MemoryStream bufferStream = new MemoryStream(data))
                        using (BinaryReader bufferReader = new BinaryReader(bufferStream)) {
                            GhostNetFrame frame = new GhostNetFrame();
                            frame.Read(bufferReader);
                            // Logger.Log(LogLevel.Verbose, "ghostnet-con", "Received update frame");
                            ReceiveUpdate(remote, frame);
                        }
                } catch (Exception e) {
                    Logger.Log(LogLevel.Warn, "ghostnet-con", "Failed parsing update frame");
                    LogContext(LogLevel.Warn);
                    e.LogDetailed();
                    Console.WriteLine("Data:");
                    Console.WriteLine(data.ToHexadecimalString());
                    // Don't dispose - maybe upcoming data isn't broken?
                }
            }
        }
Exemple #31
0
 private void ReceiveData()
 {
     client = new UdpClient(port);
     while (true) {
         try	{
             IPEndPoint anyIP = new IPEndPoint(IPAddress.Broadcast, port);
             byte[] data = client.Receive(ref anyIP);
             strReceiveUDP = Encoding.UTF8.GetString(data);
             // Simple Debug. Must be replaced with SendMessage for example.
             Debug.Log(strReceiveUDP);
             //
         }
         catch (Exception err) {
             print(err.ToString());
         }
     }
 }
	private void ReceiveData(){
		client = new UdpClient (port);
		while (true) {
			try{
				IPEndPoint anyIP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
				byte[] data = client.Receive(ref anyIP);

				string text = Encoding.UTF8.GetString(data);
				print (">> " + text);
				lastReceivedUDPPacket=text;
				allReceivedUDPPackets=allReceivedUDPPackets+text;
				xPos = float.Parse(text);
				xPos *= 0.021818f;
			}catch(Exception e){
				print (e.ToString());
			}
		}
	}
 private void ReceiveData()
 {
     UdpClient client = new UdpClient(26000);
     while (true) {
         try
         {
             if(m_Process.HasExited)
                 return;
             IPEndPoint anyIP = new IPEndPoint(IPAddress.Broadcast, 26000);
             byte[] data = client.Receive(ref anyIP);
             m_Word = Encoding.UTF8.GetString(data);
         }
         catch (Exception err)
         {
             print(err.ToString());
         }
     }
 }
        private string Send(string message)
        {
            lock (communicationLock)
            {
                // clean all pending messages from receive buffer before sending command
                while (udpClient.Available > 0)
                {
                    udpClient.Receive(ref sender);
                }
                //Send
                byte[] commandBytes = Encoding.ASCII.GetBytes(message);
                udpClient.Send(commandBytes, commandBytes.Length);
                //Receive
                byte[] answerBytes = udpClient?.Receive(ref sender);

                return(Encoding.ASCII.GetString(answerBytes));
            }
        }
Exemple #35
0
 private void Receiver()
 {
     try
     {
         var localPort = int.Parse(LocalPort);
         _receivingUdpClient = new UdpClient(localPort);
         IPEndPoint remoteIpEndPoint = null;
         while (true)
         {
             if (_isTimeToExit)
             {
                 return;
             }
             byte[] receiveBytes = _receivingUdpClient?.Receive(ref remoteIpEndPoint);
             if (receiveBytes != null && ContainHead(receiveBytes, out int index))
             {
                 if (receiveBytes.Length >= Footbot.MaxIncomePacketLenght)
                 {
                     _receiveTimeout.Restart();
                     byte[] incomeData = new byte[Footbot.MaxIncomePacketLenght];
                     Array.Copy(receiveBytes, index, incomeData, 0, incomeData.Length);
                     var incomeValues = Footbot.getStruct(incomeData);
                     BarrierState       = incomeValues.BarrierState;
                     Q0                 = incomeValues.Q0;
                     Q1                 = incomeValues.Q1;
                     Q2                 = incomeValues.Q2;
                     Q3                 = incomeValues.Q3;
                     Ip                 = incomeValues.Ip;
                     Voltage            = incomeValues.Voltage;
                     LeftX              = incomeValues.LeftX;
                     LeftY              = incomeValues.LeftY;
                     RightX             = incomeValues.RightX;
                     RightY             = incomeValues.RightY;
                     KickerChargeStatus = incomeValues.KickerChargeStatus;
                 }
             }
             Thread.Sleep(10);
         }
     }
     catch (Exception ex)
     {
         Console.WriteLine("Возникло исключение: " + ex.ToString() + "\n  " + ex.Message);
     }
 }
 // Update is called once per frame
 void ReceiveData()
 {
     client = new UdpClient (port);
     while (true)
     {
         try
         {
             IPEndPoint anyIP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
             byte[] data = client.Receive(ref anyIP);
             string text = Encoding.UTF8.GetString(data);
             string[] delimiters = {", ", ","};
             texts = text.Split(delimiters,StringSplitOptions.None);
         }
         catch(Exception e)
         {
             Debug.LogError (e.ToString());
         }
     }
 }
Exemple #37
0
        [MethodImpl(MethodImplOptions.AggressiveInlining)]        //関数のインライン展開を積極的にやってもらう.
        private void ReadingMethod()
        {
            IPEndPoint ipEP = new IPEndPoint(IPAddress.Any, 0);

            try
            {
                byte[] ba = UCR?.Receive(ref ipEP);
                if (disposing)
                {
                    return;
                }
                _ = Task.Run(ReadingMethod);                //再帰的
                DataReceived(ba, ipEP);
            }
            catch (ObjectDisposedException)
            {
                Console.WriteLine("udpcom ::: ReadingMethod => ObjectDisposed.");
            }
        }
Exemple #38
0
    static void Main(string[] args)
    {
        //Setup UDP client
        int listenport = 9000;
        UdpClient listener = new UdpClient (listenport);
        Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

        //Initialize ip and command from args
        IPAddress sendIP = IPAddress.Parse (args[0]);
        string sendCommand = args[1];

        //Send command
        byte[] sendbuf = Encoding.ASCII.GetBytes (sendCommand);
        IPEndPoint sendEP = new IPEndPoint (sendIP, listenport);
        s.SendTo (sendbuf, sendEP);

        //Wait for answer and output to console
        byte[] bytes = listener.Receive (ref sendEP);
        Console.WriteLine (Encoding.ASCII.GetString (bytes, 0, bytes.Length));
    }
Exemple #39
0
        public void Execute()
        {
            Thread listManager = null;

            try
            {
                //join muticast and listen at 64537 port
                udpServer = new UdpClient(Utilities.multicastEndPoint.Port);
                udpServer.JoinMulticastGroup(Utilities.multicastEndPoint.Address);

                //create thread to manage userlist
                listManager = new Thread(this.ListManager);
                listManager.Start();

                //wait for data or for closeServerUDP
                while (true)
                {
                    while (udpServer.Available == 0 && !closeServerUDP)
                    {
                        //wait for 0,1 seconds
                        Thread.Sleep(100);
                    }
                    if (!closeServerUDP && udpServer.Available > 0)
                    {
                        //Datagram received and put it into temp list
                        IPEndPoint RemoteIpEndPoint = new IPEndPoint(0, 0);
                        byte[]     data             = udpServer.Receive(ref RemoteIpEndPoint);
                        queue.Enqueue(new Tuple <byte[], IPEndPoint>(data, RemoteIpEndPoint));
                        newData.Set();
                    }
                    else if (closeServerUDP)
                    {
                        //if closeServerUDP is true exit
                        break;
                    }
                }

                //leave multicast group and close udpclient (finally)
                udpServer.DropMulticastGroup(Utilities.multicastEndPoint.Address);
                udpServer.Close();

                //close ListSetter
                listManager.Join();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());

                //close socket
                if (udpServer != null && udpServer.Client != null)
                {
                    udpServer.Close();
                }

                //close listManager
                CloseThread();
                if (listManager != null)
                {
                    listManager.Join();
                }

                //say to settingsform that you closed
                settingsForm.BeginInvoke(settingsForm.CloseThreadDelegate, new object[] { Thread.CurrentThread, Utilities.ServerUDP });
            }
        }
Exemple #40
0
        /*
         * Receive audio data coming on port 1550 and feed it to the speakers to be played.
         */
        public void Receive()
        {
            //TODO: Receive Sound DATA

            try
            {
                byte[] byteData;
                bStop = false;
                IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
                cGlobalVars.AddLogChat("Client Audio Connected");

                while (!bStop)
                {
                    //Receive data.
                    try
                    {
                        //bytes_received = udp_socket.ReceiveFrom(data, ref ep);

                        try
                        {
                            byteData = udpClient.Receive(ref remoteEP);
                        }
                        catch (Exception)
                        {
                            return;
                        }

                        //G711 compresses the data by 50%, so we allocate a buffer of double
                        //the size to store the decompressed data.
                        byte[] byteDecodedData = new byte[byteData.Length * 2];

                        if (vocoder == VoiceCommon.Vocoder.ALaw)
                        {
                            ALawDecoder.ALawDecode(byteData, out byteDecodedData); //Vocoder.ALaw
                        }
                        else if (vocoder == VoiceCommon.Vocoder.uLaw)
                        {
                            MuLawDecoder.MuLawDecode(byteData, out byteDecodedData); //Vocoder.uLaw
                        }
                        else
                        {
                            byteDecodedData = new byte[byteData.Length];
                            byteDecodedData = byteData;
                        }

                        bwp_internet.AddSamples(byteData, 0, byteData.Length);
                    }
                    catch (Exception)
                    {
                    }
                }
                cGlobalVars.AddLogChat("Client Audio Disconnected");
            }
            catch (Exception ex)
            {
                cGlobalVars.AddLogChat("Voice Receive > " + ex.Message);
                //MessageBox.Show(ex.Message, "VoiceChat-Receive ()", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                nUdpClientFlag += 1;
            }
        }
Exemple #41
0
        public void Listen()
        {
            while (true)
            {
                string receivedData = "";
                try
                {
                    receivedData = GetString(ClientHandler.Receive(ref EndPoint));
                }
                catch (Exception e)
                {
                    Disconnect();
                }
                string[] datas = receivedData.Split('|');

                if (!isConnected)
                {
                    return;
                }

                if (receivedData.StartsWith("OK|")) // Connection success
                {
                    CConsole.addMessage("Connection succeed to " + EndPoint.ToString() + " (" + receivedData.Replace("OK|", "") + ")!");
                    timerSendInfo = new Timer(new TimerCallback(SendServerInformations), null, 1000, tickRate);
                }
                else if (receivedData.StartsWith("JOIN|")) // New player
                {
                    int id = Int32.Parse(datas[1]);

                    if (listPlayers.ContainsKey(id))
                    {
                        PlayerDisconnected(id);
                    }

                    CPlayer newPlayer = new CPlayer(id, datas[2], (Vector3)ExtractDataFromString(datas[3], SentData.Vector3));
                    listPlayers.Add(id, newPlayer);
                }
                else if (receivedData.StartsWith("SETINFO|")) // New player
                {
                    int ID;
                    if (Int32.TryParse(datas[1], out ID) && listPlayers.ContainsKey(ID))
                    {
                        listPlayers[ID].SetNewPos((Vector3)ExtractDataFromString(datas[2], SentData.Vector3), (Vector3)ExtractDataFromString(datas[3], SentData.Vector3));
                        listPlayers[ID].SetCrouched((bool)ExtractDataFromString(datas[4], SentData.Bool));
                        listPlayers[ID].gunId = (int)ExtractDataFromString(datas[5], SentData.Int);
                        listPlayers[ID].SetJump((bool)ExtractDataFromString(datas[6], SentData.Bool));
                        listPlayers[ID].SetReload((bool)ExtractDataFromString(datas[8], SentData.Bool));
                        listPlayers[ID].SetShot((bool)ExtractDataFromString(datas[9], SentData.Bool));
                        listPlayers[ID].SetSwitch((bool)ExtractDataFromString(datas[10], SentData.Bool));
                        listPlayers[ID].SetWalk((bool)ExtractDataFromString(datas[11], SentData.Bool));

                        if (listPlayers[ID].botController._selectedWeap != listPlayers[ID].gunId)
                        {
                            listPlayers[ID].botController._selectedWeap = listPlayers[ID].gunId;
                        }
                    }
                }
                else if (receivedData.StartsWith("QUIT|")) // Server message
                {
                    int ID;
                    if (Int32.TryParse(datas[1], out ID))
                    {
                        PlayerDisconnected(ID);
                    }
                }
                else if (receivedData.StartsWith("ECHO|")) // Server message
                {
                    CConsole.addMessage("Server: " + receivedData.Replace("ECHO|", ""));
                }
                else if (receivedData.StartsWith("PLGOTHIT|"))
                {
                    int ID;
                    if (Int32.TryParse(datas[1], out ID) && listPlayers.ContainsKey(ID))
                    {
                        listPlayers[ID].ReceiveHit((int)ExtractDataFromString(datas[3], SentData.Int), datas[2]);
                    }
                }
                else if (receivedData.StartsWith("UGOTHIT|"))
                {
                    int ID;
                    if (Int32.TryParse(datas[1], out ID) && listPlayers.ContainsKey(ID))
                    {
                        CConsole._Character._life -= (int)ExtractDataFromString(datas[3], SentData.Int);
                    }
                }
            }
        }
Exemple #42
0
        private void StartWebRtcRtpListener(IceCandidate iceCandidate)
        {
            string localEndPoint = "?";

            try
            {
                localEndPoint = iceCandidate.LocalRtpSocket.LocalEndPoint.ToString();

                logger.Debug("Starting WebRTC RTP listener for call " + CallID + " on socket " + localEndPoint + ".");

                IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
                UdpClient  localSocket    = new UdpClient();
                localSocket.Client = iceCandidate.LocalRtpSocket;

                while (!IsClosed)
                {
                    try
                    {
                        //logger.Debug("ListenToReceiverWebRTCClient Receive.");
                        byte[] buffer = localSocket.Receive(ref remoteEndPoint);

                        iceCandidate.LastCommunicationAt = DateTime.Now;

                        //logger.Debug(buffer.Length + " bytes read on Receiver Client media socket from " + remoteEndPoint.ToString() + ".");

                        //if (buffer.Length > 3 && buffer[0] == 0x16 && buffer[1] == 0xfe)
                        if (buffer[0] >= 20 && buffer[0] <= 64)
                        {
                            //OnMediaPacket(iceCandidate, buffer, remoteEndPoint);
                            if (OnDtlsPacket != null)
                            {
                                OnDtlsPacket(iceCandidate, buffer, remoteEndPoint);
                            }
                        }
                        //else if ((buffer[0] & 0x80) == 0)
                        else if (buffer[0] == 0 || buffer[0] == 1)
                        {
                            STUNv2Message stunMessage = STUNv2Message.ParseSTUNMessage(buffer, buffer.Length);
                            ProcessStunMessage(iceCandidate, stunMessage, remoteEndPoint);
                        }
                        else
                        {
                            if (OnMediaPacket != null)
                            {
                                OnMediaPacket(iceCandidate, buffer, remoteEndPoint);
                            }
                        }
                    }
                    catch (Exception sockExcp)
                    {
                        _communicationFailureCount++;

                        logger.Warn("Exception ListenToReceiverWebRTCClient Receive (" + localEndPoint + " and " + remoteEndPoint + ", failure count " + _communicationFailureCount + "). " + sockExcp.Message);

                        // Need to be careful about deciding when the connection has failed. Sometimes the STUN requests we send will arrive before the remote peer is ready and cause a socket exception.
                        // Only shutdown the peer if we are sure all ICE intialisation is complete and the socket exception occurred after the RTP had stated flowing.
                        if (iceCandidate.IsStunLocalExchangeComplete && iceCandidate.IsStunRemoteExchangeComplete &&
                            iceCandidate.RemoteRtpEndPoint != null && remoteEndPoint != null && iceCandidate.RemoteRtpEndPoint.ToString() == remoteEndPoint.ToString() &&
                            DateTime.Now.Subtract(IceNegotiationStartedAt).TotalSeconds > 10)
                        {
                            logger.Warn("WebRtc peer communication failure on call " + CallID + " for local RTP socket " + localEndPoint + " and remote RTP socket " + remoteEndPoint + " .");
                            iceCandidate.DisconnectionMessage = sockExcp.Message;
                            break;
                        }
                        else if (_communicationFailureCount > COMMUNICATION_FAILURE_COUNT_FOR_CLOSE)
                        {
                            logger.Warn("WebRtc peer communication failures on call " + CallID + " exceeded limit of " + COMMUNICATION_FAILURE_COUNT_FOR_CLOSE + " closing peer.");
                            break;
                        }
                        //else if (DateTime.Now.Subtract(peer.IceNegotiationStartedAt).TotalSeconds > ICE_CONNECTION_LIMIT_SECONDS)
                        //{
                        //    logger.Warn("WebRTC peer ICE connection establishment timed out on call " + peer.CallID + " for " + iceCandidate.LocalRtpSocket.LocalEndPoint + ".");
                        //    break;
                        //}
                    }
                }

                Close();
            }
            catch (Exception excp)
            {
                logger.Error("Exception ListenForWebRTCClient (" + localEndPoint + "). " + excp);
            }
        }
        /// <summary>
        /// The compile.
        /// </summary>
        /// <param name="asset">
        /// The asset.
        /// </param>
        /// <param name="platform">
        /// The platform.
        /// </param>
        public void Compile(EffectAsset asset, TargetPlatform platform)
        {
            var announceString = Encoding.ASCII.GetBytes("request compiler");

            var targetAddress = IPAddress.None;
            var client        = new UdpClient(4321);

            client.Client.ReceiveTimeout = 500;

            try
            {
                client.Send(announceString, announceString.Length, new IPEndPoint(IPAddress.Broadcast, 4321));
            }
            catch (SocketException)
            {
                Console.WriteLine("WARNING: Unable to locate remote compiler for effect compilation.");
                return;
            }

            var endpoint = new IPEndPoint(IPAddress.Loopback, 4321);

            try
            {
                var bytes = client.Receive(ref endpoint);

                while (Encoding.ASCII.GetString(bytes) == "request compiler")
                {
                    bytes = client.Receive(ref endpoint);
                }

                if (Encoding.ASCII.GetString(bytes) == "provide compiler")
                {
                    targetAddress = endpoint.Address;
                }
                else
                {
                    Console.WriteLine("WARNING: Received unexpected message from " + endpoint + " when locating remote effect compiler.");
                    return;
                }
            }
            catch
            {
                Console.WriteLine("WARNING: Unable to locate remote compiler for effect compilation.");
                return;
            }

            // Connect to the target on port 80.
            var webClient = new WebClient();

            try
            {
                var result = webClient.UploadData("http://" + targetAddress + ":8080/compileeffect?platform=" + (int)platform, Encoding.ASCII.GetBytes(asset.Code));

                asset.PlatformData = new PlatformData {
                    Platform = platform, Data = result
                };
            }
            catch (WebException ex)
            {
                using (var reader = new StreamReader(ex.Response.GetResponseStream()))
                {
                    throw new InvalidOperationException(reader.ReadToEnd());
                }
            }

            try
            {
                asset.ReloadEffect();
            }
            catch (NoAssetContentManagerException)
            {
            }
        }
Exemple #44
0
    public void ReceiveUDP()
    {
        try
        {
            //Open the Kinect Process
            procKinect = new Process();
            path       = path.Replace("/Assets", "");
            UnityEngine.Debug.Log(path);

            ProcessStartInfo info = new ProcessStartInfo(path);

            procKinect = Process.Start(info);

            Thread.Sleep(1000);
            SetFocusOnROCHE();
            ToggleKWindow();

            // Kinect launched. Do upd call.
            kinectLaunched = true;
            udpc           = new UdpClient("127.0.0.1", 2055);
            Thread.Sleep(1000);

            // while bucle
            while (Thread.CurrentThread.IsAlive)
            {
                //we can send a 'request' string if we want
                string name  = "RH";
                byte[] sdata = Encoding.ASCII.GetBytes(name);
                udpc.Send(sdata, sdata.Length);

                // Receive data
                byte[] rdata = udpc.Receive(ref ep);
                currentPacket = Encoding.ASCII.GetString(rdata);

                // There's no packet, sleep for a bit
                if (currentPacket == null || currentPacket == "null")
                {
                    Thread.Sleep(20);
                }
                else
                {
                    string[] coords = currentPacket.Split('-');
                    currentHandUsed = Convert.ToString(coords[0]);

                    if (currentHandUsed == "r")
                    {
                        GetRightHandInput(coords);
                        leftHand.Reset();
                    }
                    else if (currentHandUsed == "l")
                    {
                        GetLeftHandInput(coords);
                        rightHand.Reset();
                    }
                }
                Thread.Sleep(5);
            }
        } catch (Exception ex)
        {
            ReleaseEverything();
            UnityEngine.Debug.Log(ex.Message);
        }
    }
        /*
         * Prati odometriju
         */
        public static void Work()
        {
            Byte[]     sendBytes;
            Byte[]     receiveBytes;
            Byte[]     sbuf;
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);

            //udpClient.Send(sendBytes, sendBytes.Length);

            //IPEndPoint object will allow us to read datagrams sent from any source.


            // Blocks until a message returns on this socket from a remote host.
            // = udpClient.Receive(ref RemoteIpEndPoint);
            //string returnData = Encoding.ASCII.GetString(receiveBytes);

            // Uses the IPEndPoint object to determine which of these two hosts responded.
            //Console.WriteLine("This is the message you received " + returnData.ToString());
            //Console.WriteLine("This message was sent from " + RemoteIpEndPoint.Address.ToString() + " on their port number " + RemoteIpEndPoint.Port.ToString());

            //Console.WriteLine("pLevo: " + (plevo).ToString() + "\t= ");
            //Console.WriteLine("pDesno:" + (pdesno).ToString() + "\t= ");
            ////Console.WriteLine("UgaoL: " + ((plevo - levo) / 3.1).ToString());
            ////Console.WriteLine("UgaoD: " + (((pdesno - desno)) / 3.1).ToString());
            //Console.WriteLine("---------------------------------------------");
            //Console.WriteLine("mLevo: " + (plevo - levo).ToString() + "\t= " + ((plevo - levo) * 1.34 / 1000).ToString() + "m");
            //Console.WriteLine("mDesno:" + (pdesno - desno).ToString() + "\t= " + ((pdesno - desno) * 1.34 / 1000).ToString() + "m");
            //Console.WriteLine("mUgaoL: " + ((plevo - levo) / 3.1).ToString());
            //Console.WriteLine("mUgaoD: " + (((pdesno - desno)) / 3.1).ToString());

            /* while (true)
             * {*/
            sendBytes = Encoding.ASCII.GetBytes("data");
            udpClient.Send(sendBytes, sendBytes.Length);
            sbuf = udpClient.Receive(ref RemoteIpEndPoint);
            System.Threading.Thread.Sleep(100);
            levo  = ((((long)sbuf[8] << 24)) + (((long)sbuf[7] << 16)) + (((long)sbuf[6] << 8)) + ((long)sbuf[5])) - greska;
            desno = ((((long)sbuf[16] << 24)) + (((long)sbuf[15] << 16)) + (((long)sbuf[14] << 8)) + ((long)sbuf[13])) - greska;
            //Console.WriteLine("Levo: " + (levo).ToString());
            //Console.WriteLine("Desno:" + (desno).ToString());
            //stavljamo trenutni kao pocetni
            //plevo = lLevo;
            // = lDesno;
            //180995 - 153718
            //returnData = Encoding.ASCII.GetString(receiveBytes);
            //Console.Clear();
            //Console.WriteLine(String.Format("X:{0} Y:{1} theta:{2}", current_position.x, current_position.y, current_position.theta * 180 / PI));

            left_ticks  = plevo - levo;
            right_ticks = pdesno - desno;
            plevo       = levo;
            pdesno      = desno;

            //Console.WriteLine("ticks L:" + left_ticks);
            //Console.WriteLine("ticks R:" + right_ticks);
            dist_left  = (double)left_ticks * MUL_COUNT;
            dist_right = (double)right_ticks * MUL_COUNT;
            //Console.WriteLine("distance L:" + dist_left);
            //Console.WriteLine("distance R:" + dist_right);

            cos_current = System.Math.Cos(current_position.theta);
            sin_current = System.Math.Sin(current_position.theta);

            current_position.x = System.Math.Round(current_position.x, 3);
            current_position.y = System.Math.Round(current_position.y, 3);

            if (System.Math.Abs(left_ticks - right_ticks) <= 10)
            {
                /* Moving in a straight line */
                current_position.x += System.Math.Round(dist_left * cos_current, 3);
                current_position.y += System.Math.Round(dist_left * sin_current, 3);
            }
            else
            {
                /* Moving in an arc */
                expr1               = AXLE_LENGTH * (dist_right + dist_left) / 2.0 / (dist_right - dist_left);
                right_minus_left    = dist_right - dist_left;
                current_position.x += System.Math.Round(expr1 * (System.Math.Sin(right_minus_left / AXLE_LENGTH + current_position.theta) - sin_current), 3);
                current_position.y -= System.Math.Round(expr1 * (System.Math.Cos(right_minus_left / AXLE_LENGTH + current_position.theta) - cos_current), 3);
                /* Calculate new orientation */
                current_position.theta += right_minus_left / AXLE_LENGTH;
                /*Keep in the range -PI to +PI */

                while (current_position.theta > PI)
                {
                    current_position.theta -= (2.0 * PI);
                }
                while (current_position.theta < -PI)
                {
                    current_position.theta += (2.0 * PI);
                }

                /* while (current_position.theta > 2*PI)
                 *   current_position.theta = 0;
                 * while (current_position.theta < 0)
                 *   current_position.theta = 2.0 * PI;*/
            }

            System.Threading.Thread.Sleep(delay);
            //}
        }
Exemple #46
0
    // Update is called once per frame
    void Update()
    {
        if (inclient.Available > 0)
        {
            byte[] data = inclient.Receive(ref inremoteEndPoint);

            scenario = System.BitConverter.ToDouble(data, 0);
        }

        Debug.Log(scenario);

        if (scenario != prevScenario)
        {
            prevScenario = scenario;
            if (scenario == 0)
            {
                //Switch off everything
                transform.localPosition = Vector3.zero;
                transform.localScale    = Vector3.zero;
                propellers.MuteAll();
                movement.move = false;
            }
            else
            {
                if (scenario == 1)
                {
                    //Posn A
                    transform.localPosition = startPosnA;
                }
                else if (scenario == 2)
                {
                    //Posn B
                    transform.localPosition = startPosnB;
                }
                else if (scenario == 3)
                {
                    //Posn C
                    transform.localPosition = startPosnC;
                }

                transform.localScale = droneScale * Vector3.one;
                propellers.UnmuteAll();
                movement.move = true;
            }
        }

        byte[] outdata = new byte[28];

        byte[] vxout = new byte[4];
        byte[] vyout = new byte[4];
        byte[] vzout = new byte[4];

        byte[] dxout = new byte[4];
        byte[] dyout = new byte[4];
        byte[] dzout = new byte[4];

        byte[] startout = new byte[4];

        vxout = System.BitConverter.GetBytes(movement.vx);
        vyout = System.BitConverter.GetBytes(movement.vy);
        vzout = System.BitConverter.GetBytes(movement.vz);

        dxout = System.BitConverter.GetBytes(transform.localPosition.x - mainCamera.transform.localPosition.x);
        dyout = System.BitConverter.GetBytes(transform.localPosition.z - mainCamera.transform.localPosition.z);
        dzout = System.BitConverter.GetBytes(transform.localPosition.y - mainCamera.transform.localPosition.y);

        startout = System.BitConverter.GetBytes(1.0f);

        System.Buffer.BlockCopy(vxout, 0, outdata, 0, 4);
        System.Buffer.BlockCopy(vyout, 0, outdata, 4, 4);
        System.Buffer.BlockCopy(vzout, 0, outdata, 8, 4);
        System.Buffer.BlockCopy(dxout, 0, outdata, 12, 4);
        System.Buffer.BlockCopy(dyout, 0, outdata, 16, 4);
        System.Buffer.BlockCopy(dzout, 0, outdata, 20, 4);
        System.Buffer.BlockCopy(startout, 0, outdata, 24, 4);

        sendSocket.SendTo(outdata, sendEndPoint);
    }
Exemple #47
0
 void receiveData()
 {
     receiveBytes = udpClient.Receive(ref ep);
 }
Exemple #48
0
        void ToOpen()
        {
            var ip    = UDP_type_multicast.IsChecked ?? false ? IPAddress.Any : UDP_Local_ip.Ip;
            var mport = UDP_Local_port.Port;

            if (!mport.HasValue)
            {
                return;
            }
            int port = mport.Value;

            try
            {
                var uc = new UdpClient(new IPEndPoint(ip, port));
                socket = uc;
                port   = ((IPEndPoint)uc.Client.LocalEndPoint).Port;

                MsgBox.LogSystem($"Open on {{ {ip} :{port} }}");

                SetEnables();

                uc.EnableBroadcast = UDP_type_broadcast.IsChecked ?? false;

                if (UDP_type_broadcast.IsChecked ?? false)
                {
                    MsgBox.LogSystem($"Enabled Broadcast on {{ {UDP_Target_ip.Ip} }}");
                }

                if (UDP_type_multicast.IsChecked ?? false)
                {
                    var mip = UDP_multicast_ip.Text.ParseIp();

                    sendClients = new List <UdpClient>();

                    var msgs = (from networkInterface in NetworkInterface.GetAllNetworkInterfaces()
                                where networkInterface.OperationalStatus == OperationalStatus.Up
                                select networkInterface.GetIPProperties()
                                .UnicastAddresses.First(addr =>
                                                        addr.Address.AddressFamily == AddressFamily.InterNetwork)?.Address)
                               .Where(address => address != null)
                               .Select(addr =>
                    {
                        uc.JoinMulticastGroup(mip, addr);
                        sendClients.Add(new UdpClient(new IPEndPoint(addr, port)));
                        return($"Join Multicast Group {{ {mip} on {addr} }}");
                    });

                    MsgBox.LogSystem(msgs.ToArray());

                    //uc.JoinMulticastGroup(mip);
                    //LogSystem($"Join Multicast Group {{ {mip} }}");
                }

                loop = new CancellationTokenSource();
                loops.Add(Task.Run(() =>
                {
                    while (socket != null || socket != uc)
                    {
                        try
                        {
                            var ep = new IPEndPoint(IPAddress.Any, 0);

                            var buffer = uc.Receive(ref ep);

                            var str = Encoding.Default.GetString(buffer);

                            MsgBox.Log(ep, str, true);
                        }
                        catch (Exception ex)
                        {
                            if (socket == null || socket != uc)
                            {
                                MsgBox.LogSystem("Closed");
                            }
                            else
                            {
                                MsgBox.LogError(ex);
                            }
                            return;
                        }
                    }
                }, loop.Token));
            }
            catch (Exception ex)
            {
                MsgBox.LogError(ex);
                return;
            }
        }
Exemple #49
0
        private void Listen()
        {
            try
            {
                UdpClient udpSvr = m_udpListener;

                if (udpSvr == null)
                {
                    logger.LogError("The UDP server was not correctly initialised in the RTP sink when attempting to start the listener, the RTP stream has not been intialised.");
                    return;
                }
                else
                {
                    logger.LogDebug("RTP Listener now listening on " + m_localEndPoint.Address + ":" + m_localEndPoint.Port + ".");
                }

                IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
                byte[]     rcvdBytes      = null;

                m_startRTPReceiveTime = DateTime.MinValue;
                m_lastRTPReceivedTime = DateTime.MinValue;
                DateTime previousRTPReceiveTime = DateTime.MinValue;
                uint     previousTimestamp      = 0;
                UInt16   sequenceNumber         = 0;
                UInt16   previousSeqNum         = 0;
                uint     senderSendSpacing      = 0;
                uint     lastSenderSendSpacing  = 0;

                while (!StopListening)
                {
                    rcvdBytes = null;

                    try
                    {
                        rcvdBytes = udpSvr.Receive(ref remoteEndPoint);
                    }
                    catch
                    {
                        //logger.LogWarning("Remote socket closed on receive. Last RTP received " + m_lastRTPReceivedTime.ToString("dd MMM yyyy HH:mm:ss") + ", last RTP successfull send " +  m_lastRTPSentTime.ToString("dd MMM yyyy HH:mm:ss") + ".");
                    }

                    if (rcvdBytes != null && rcvdBytes.Length > 0)
                    {
                        // Check whether this is an RTCP report.
                        UInt16 firstWord = BitConverter.ToUInt16(rcvdBytes, 0);
                        if (BitConverter.IsLittleEndian)
                        {
                            firstWord = NetConvert.DoReverseEndian(firstWord);
                        }

                        ushort packetType = 0;
                        if (BitConverter.IsLittleEndian)
                        {
                            packetType = Convert.ToUInt16(firstWord & 0x00ff);
                        }

                        if (packetType == RTCPHeader.RTCP_PACKET_TYPE)
                        {
                            logger.LogDebug("RTP Listener received remote RTCP report from " + remoteEndPoint + ".");

                            try
                            {
                                RTCPPacket       rtcpPacket       = new RTCPPacket(rcvdBytes);
                                RTCPReportPacket rtcpReportPacket = new RTCPReportPacket(rtcpPacket.Reports);

                                if (RTCPReportReceived != null)
                                {
                                    RTCPReportReceived(this, rtcpReportPacket);
                                }
                            }
                            catch (Exception rtcpExcp)
                            {
                                logger.LogError("Exception processing remote RTCP report. " + rtcpExcp.Message);
                            }

                            continue;
                        }

                        // Channel statistics.
                        DateTime rtpReceiveTime = DateTime.Now;
                        if (m_startRTPReceiveTime == DateTime.MinValue)
                        {
                            m_startRTPReceiveTime = rtpReceiveTime;
                            //m_sampleStartTime = rtpReceiveTime;
                        }
                        previousRTPReceiveTime = new DateTime(m_lastRTPReceivedTime.Ticks);
                        m_lastRTPReceivedTime  = rtpReceiveTime;
                        m_packetsReceived++;
                        m_bytesReceived += rcvdBytes.Length;

                        previousSeqNum = sequenceNumber;

                        // This stops the thread running the ListenerTimeout method from deciding the strema has recieved no RTP and therefore should be shutdown.
                        m_lastPacketReceived.Set();

                        // Let whoever has subscribed that an RTP packet has been received.
                        if (DataReceived != null)
                        {
                            try
                            {
                                DataReceived(m_streamId, rcvdBytes, remoteEndPoint);
                            }
                            catch (Exception excp)
                            {
                                logger.LogError("Exception RTPSink DataReceived. " + excp.Message);
                            }
                        }

                        if (m_packetsReceived % 500 == 0)
                        {
                            logger.LogDebug("Total packets received from " + remoteEndPoint.ToString() + " " + m_packetsReceived + ", bytes " + NumberFormatter.ToSIByteFormat(m_bytesReceived, 2) + ".");
                        }

                        try
                        {
                            RTPPacket rtpPacket  = new RTPPacket(rcvdBytes);
                            uint      syncSource = rtpPacket.Header.SyncSource;
                            uint      timestamp  = rtpPacket.Header.Timestamp;
                            sequenceNumber = rtpPacket.Header.SequenceNumber;

                            //logger.LogDebug("seqno=" + rtpPacket.Header.SequenceNumber + ", timestamp=" + timestamp);

                            if (previousRTPReceiveTime != DateTime.MinValue)
                            {
                                //uint senderSendSpacing = rtpPacket.Header.Timestamp - previousTimestamp;
                                // Need to cope with cases where the timestamp has looped, if this timestamp is < last timesatmp and there is a large difference in them then it's because the timestamp counter has looped.
                                lastSenderSendSpacing = senderSendSpacing;
                                senderSendSpacing     = (Math.Abs(timestamp - previousTimestamp) > (uint.MaxValue / 2)) ? timestamp + uint.MaxValue - previousTimestamp : timestamp - previousTimestamp;

                                if (previousTimestamp > timestamp)
                                {
                                    logger.LogError("BUG: Listener previous timestamp (" + previousTimestamp + ") > timestamp (" + timestamp + "), last seq num=" + previousSeqNum + ", seqnum=" + sequenceNumber + ".");

                                    // Cover for this bug until it's nailed down.
                                    senderSendSpacing = lastSenderSendSpacing;
                                }

                                double senderSpacingMilliseconds = (double)senderSendSpacing / (double)TIMESTAMP_FACTOR;
                                double interarrivalReceiveTime   = m_lastRTPReceivedTime.Subtract(previousRTPReceiveTime).TotalMilliseconds;

                                #region RTCP reporting.

                                if (m_rtcpSampler == null)
                                {
                                    //resultslogger.LogInformation("First Packet: " + rtpPacket.Header.SequenceNumber + "," + m_arrivalTime.ToString("HH:mm:fff"));

                                    m_rtcpSampler = new RTCPReportSampler(m_streamId, syncSource, remoteEndPoint, rtpPacket.Header.SequenceNumber, m_lastRTPReceivedTime, rcvdBytes.Length);
                                    m_rtcpSampler.RTCPReportReady += new RTCPSampleReadyDelegate(m_rtcpSampler_RTCPReportReady);
                                    m_rtcpSampler.StartSampling();
                                }
                                else
                                {
                                    //m_receiverReports[syncSource].RecordRTPReceive(rtpPacket.Header.SequenceNumber, sendTime, rtpReceiveTime, rcvdBytes.Length);
                                    // Transit time is calculated by knowing that the sender sent a packet at a certain time after the last send and the receiver received a pakcet a certain time after the last receive.
                                    // The difference in these two times is the jitter present. The transit time can change with each transimission and as this methid relies on two sends two packet
                                    // arrivals to calculate the transit time it's not going to be perfect (you'd need synchronised NTP clocks at each end to be able to be accurate).
                                    // However if used tor an average calculation it should be pretty close.
                                    //double transitTime = Math.Abs(interarrivalReceiveTime - senderSpacingMilliseconds);
                                    uint jitter = (interarrivalReceiveTime - senderSpacingMilliseconds > 0) ? Convert.ToUInt32(interarrivalReceiveTime - senderSpacingMilliseconds) : 0;

                                    if (jitter > 75)
                                    {
                                        logger.LogDebug("seqno=" + rtpPacket.Header.SequenceNumber + ", timestmap=" + timestamp + ", ts-prev=" + previousTimestamp + ", receive spacing=" + interarrivalReceiveTime + ", send spacing=" + senderSpacingMilliseconds + ", jitter=" + jitter);
                                    }
                                    else
                                    {
                                        //logger.LogDebug("seqno=" + rtpPacket.Header.SequenceNumber + ", receive spacing=" + interarrivalReceiveTime + ", timestamp=" + timestamp + ", transit time=" + transitTime);
                                    }

                                    m_rtcpSampler.RecordRTPReceive(m_lastRTPReceivedTime, rtpPacket.Header.SequenceNumber, rcvdBytes.Length, jitter);
                                }

                                #endregion
                            }
                            else
                            {
                                logger.LogDebug("RTPSink Listen SyncSource=" + rtpPacket.Header.SyncSource + ".");
                            }

                            previousTimestamp = timestamp;
                        }
                        catch (Exception excp)
                        {
                            logger.LogError("Received data was not a valid RTP packet. " + excp.Message);
                        }

                        #region Switching endpoint if required to cope with NAT.

                        // If a packet is recieved from an endpoint that wasn't expected treat the stream as being NATted and switch the endpoint to the socket on the NAT server.
                        try
                        {
                            if (m_streamEndPoint != null && m_streamEndPoint.Address != null && remoteEndPoint != null && remoteEndPoint.Address != null && (m_streamEndPoint.Address.ToString() != remoteEndPoint.Address.ToString() || m_streamEndPoint.Port != remoteEndPoint.Port))
                            {
                                logger.LogDebug("Expecting RTP on " + IPSocket.GetSocketString(m_streamEndPoint) + " but received on " + IPSocket.GetSocketString(remoteEndPoint) + ", now sending to " + IPSocket.GetSocketString(remoteEndPoint) + ".");
                                m_streamEndPoint = remoteEndPoint;

                                if (RemoteEndPointChanged != null)
                                {
                                    try
                                    {
                                        RemoteEndPointChanged(m_streamId, remoteEndPoint);
                                    }
                                    catch (Exception changeExcp)
                                    {
                                        logger.LogError("Exception RTPListener Changing Remote EndPoint. " + changeExcp.Message);
                                    }
                                }
                            }
                        }
                        catch (Exception setSendExcp)
                        {
                            logger.LogError("Exception RTPListener setting SendTo Socket. " + setSendExcp.Message);
                        }

                        #endregion
                    }
                    else if (!StopListening) // Empty packet was received possibly indicating connection closure so check for timeout.
                    {
                        double noRTPRcvdDuration = (m_lastRTPReceivedTime != DateTime.MinValue) ? DateTime.Now.Subtract(m_lastRTPReceivedTime).TotalSeconds : 0;
                        double noRTPSentDuration = (m_lastRTPSentTime != DateTime.MinValue) ? DateTime.Now.Subtract(m_lastRTPSentTime).TotalSeconds : 0;

                        //logger.LogWarning("Remote socket closed on receive on " + m_localEndPoint.Address.ToString() + ":" + + m_localEndPoint.Port + ", reinitialising. No rtp for " + noRTPRcvdDuration + "s. last rtp " + m_lastRTPReceivedTime.ToString("dd MMM yyyy HH:mm:ss") + ".");

                        // If this check is not done then the stream will never time out if it doesn't receive the first packet.
                        if (m_lastRTPReceivedTime == DateTime.MinValue)
                        {
                            m_lastRTPReceivedTime = DateTime.Now;
                        }

                        remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);

                        if ((noRTPRcvdDuration > NO_RTP_TIMEOUT || noRTPSentDuration > NO_RTP_TIMEOUT) && StopIfNoData)
                        {
                            logger.LogWarning("Disconnecting RTP listener on " + m_localEndPoint.ToString() + " due to not being able to send or receive any RTP for " + NO_RTP_TIMEOUT + "s.");
                            Shutdown();
                        }
                    }
                }
            }
            catch (Exception excp)
            {
                logger.LogError("Exception Listen RTPSink: " + excp.Message);
            }
            finally
            {
                #region Shut down socket.

                Shutdown();

                if (ListenerClosed != null)
                {
                    try
                    {
                        ListenerClosed(m_streamId, m_callDescriptorId);
                    }
                    catch (Exception excp)
                    {
                        logger.LogError("Exception RTPSink ListenerClosed. " + excp.Message);
                    }
                }

                #endregion
            }
        }
        public void HandleRequests()
        {
            var endPoint = new IPEndPoint(IPAddress.Any, networkPort);

            while (true)
            {
                var requestBytes = udpServer.Receive(ref endPoint);
                var request      = Encoding.UTF8.GetString(requestBytes);
                var response     = "ERROR";

                //process the request
                //if login request, check username and password
                if (Regex.Match(request, @"^LOGIN,[A-Za-z]+,[A-Za-z0-9]+$").Success)
                {
                    string[] requestArray = request.Split(',');
                    using (var context = new NetworkedCheckersContainer())
                    {
                        var query = from user in context.Users select user;
                        foreach (var user in query)
                        {
                            if (requestArray[1].Equals(user.UserName) && requestArray[2].Equals(user.Password) && user.LoginStatus == false)
                            {
                                user.LoginStatus = true;
                                //create string of online users
                                string allUser = "";
                                foreach (var userObj in query)
                                {
                                    if (userObj.LoginStatus == true)
                                    {
                                        allUser += userObj.UserName;
                                        allUser += ":";
                                    }
                                }
                                allUser = allUser.Remove(allUser.Length - 1);

                                BroadcastMessages("USERS," + allUser);
                                response = "OKAY";
                                break;
                            }
                        }
                        context.SaveChanges();
                    }
                }
                //if logoff request
                else if (Regex.Match(request, @"^LOGOUT,[A-Za-z]+$").Success)
                {
                    string[] requestArray = request.Split(',');
                    using (var context = new NetworkedCheckersContainer())
                    {
                        var query = from user in context.Users select user;
                        foreach (var user in query)
                        {
                            //change the login status of the designated user to false
                            if (user.UserName == requestArray[1] && user.LoginStatus == true)
                            {
                                user.LoginStatus = false;
                                break;
                            }
                        }
                        context.SaveChanges();

                        //create string of online users
                        string allUser = "";
                        foreach (var user in query)
                        {
                            if (user.LoginStatus == true)
                            {
                                allUser += user.UserName;
                                allUser += ":";
                            }
                        }
                        if (allUser != "")
                        {
                            allUser = allUser.Remove(allUser.Length - 1);
                        }

                        BroadcastMessages("USERS," + allUser);
                        response = "OKAY";
                    }
                }
                else
                {
                    switch (gamestate)
                    {
                    case GameState.WAIT_FOR_GAME_START:
                        if (Regex.Match(request, @"^PLAY,[A-Za-z]+,[A-Za-z]+$").Success)
                        {
                            string[] requestArray = request.Split(',');
                            p1Name = requestArray[1];
                            p2Name = requestArray[2];
                            if (p1Name != p2Name)
                            {
                                //set move count to 0
                                gameMoveCount = 0;
                                //set board to initial position
                                board.resetBoard();
                                gamestate = GameState.Player1_MOVING;

                                BroadcastMessages("GAMESTATE," + board.GetPieces());
                                BroadcastMessages("GAMESTART," + p1Name + "," + p2Name);
                                BroadcastMessages("STATUS," + p1Name + ",MOVING");
                                BroadcastMessages("STATUS," + p2Name + ",WAITING");
                                response = "OKAY";
                            }
                        }
                        break;

                    case GameState.Player1_MOVING:
                        if (Regex.Match(request, @"^TRY,[A-Za-z]+,[1-8][1-8],[1-8][1-8]$").Success)
                        {
                            string[] requestArray = request.Split(',');
                            //check whether this is the player's turn to move
                            if (requestArray[1].Equals(p1Name))
                            {
                                //check whether the move is valid
                                if (board.IsValidMovePlayer1(requestArray[2] + "," + requestArray[3]))
                                {
                                    //move the piece
                                    board.Move(requestArray[2], requestArray[3], Piece.PLAYER1);
                                    gameMoveCount++;

                                    BroadcastMessages("GAMESTATE," + board.GetPieces());
                                    BroadcastMessages("STATUS," + p2Name + ",MOVING");
                                    BroadcastMessages("STATUS," + p1Name + ",WAITING");
                                    response = "DONE";

                                    //check whether the player win after the move
                                    if (board.isP1Win())
                                    {
                                        gamestate = GameState.GAME_OVER;
                                        Record("Game Over. Player 1 Wins");

                                        BroadcastMessages("STATUS," + p1Name + ",WON");
                                        BroadcastMessages("STATUS," + p2Name + ",LOST");

                                        using (var context = new NetworkedCheckersContainer())
                                        {
                                            //identify the winning user from database
                                            var p1User = from user in context.Users where user.UserName.Equals(p1Name) select user;
                                            //add new highscore to Highscores table
                                            var highscore = new Highscore()
                                            {
                                                DateTime  = DateTime.Now.ToString(),
                                                MoveCount = (Int16)gameMoveCount,
                                                User      = p1User.First()
                                            };
                                            context.Highscores.Add(highscore);
                                            context.SaveChanges();
                                        }
                                        showLeaderBoard();
                                    }
                                    else
                                    {
                                        gamestate = GameState.Player2_MOVING;
                                    }
                                }
                            }
                        }
                        break;

                    case GameState.Player2_MOVING:
                        if (Regex.Match(request, @"^TRY,[A-Za-z]+,[1-8][1-8],[1-8][1-8]$").Success)
                        {
                            //check whether this is the player's turn to move
                            string[] requestArray = request.Split(',');
                            if (requestArray[1].Equals(p2Name))
                            {
                                //check whether the move is valid
                                if (board.IsValidMovePlayer2(requestArray[2] + "," + requestArray[3]))
                                {
                                    //move the piece
                                    board.Move(requestArray[2], requestArray[3], Piece.PLAYER2);
                                    gameMoveCount++;

                                    BroadcastMessages("GAMESTATE," + board.GetPieces());
                                    BroadcastMessages("STATUS," + p1Name + ",MOVING");
                                    BroadcastMessages("STATUS," + p2Name + ",WAITING");
                                    response = "DONE";

                                    //check whether the player win after the move
                                    if (board.isP2Win())
                                    {
                                        gamestate = GameState.GAME_OVER;
                                        Record("Game Over. Player 2 Wins");
                                        BroadcastMessages("STATUS," + p2Name + ",WON");
                                        BroadcastMessages("STATUS," + p1Name + ",LOST");

                                        //record the win into the database
                                        using (var context = new NetworkedCheckersContainer())
                                        {
                                            //identify the winning user from database
                                            var p2User = from user in context.Users where user.UserName.Equals(p2Name) select user;
                                            //add new highscore to Highscores table
                                            var highscore = new Highscore()
                                            {
                                                DateTime  = DateTime.Now.ToString(),
                                                MoveCount = (Int16)gameMoveCount,
                                                User      = p2User.First()
                                            };
                                            context.Highscores.Add(highscore);
                                            context.SaveChanges();
                                        }
                                        showLeaderBoard();
                                    }
                                    else
                                    {
                                        gamestate = GameState.Player1_MOVING;
                                    }
                                }
                            }
                        }
                        break;

                    case GameState.GAME_OVER:
                        if (Regex.Match(request, @"^PLAY,[A-Za-z]+,[A-Za-z]+$").Success)
                        {
                            gamestate = GameState.WAIT_FOR_GAME_START;
                            goto case GameState.WAIT_FOR_GAME_START;
                        }
                        break;
                    }
                }

                //send response
                var responseBytes = Encoding.UTF8.GetBytes(response);
                udpServer.Send(responseBytes, responseBytes.Length, endPoint);

                Record("Request: " + request);
                Record("Response: " + response);
                Record("New Game State: " + gamestate.ToString());
                Record("Current Game State: " + gamestate.ToString());
            }
        }
Exemple #51
0
        private static void runServer(string name, int port)
        {
            try
            {
                IPEndPoint addr = new IPEndPoint(IPAddress.Any, DEFAULT_PORT_REQUEST);
                client = new UdpClient();
                client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                client.ExclusiveAddressUse = false;
                client.Client.Bind(addr);

                Log.debug("LAN Discovery: Starting to listen");

                running = true;
                while (running)
                {
                    IPEndPoint other = null;
                    byte[]     bytes = client.Receive(ref other);
                    if (bytes.Length < MAGIC.Length + 1)
                    {
                        continue;
                    }
                    Log.debug("LAN Discovery: Received a request from " + other);

                    bool okay = true;
                    for (int i = 0; i < MAGIC.Length; ++i)
                    {
                        if (bytes[i] != MAGIC[i])
                        {
                            okay = false;
                            break;
                        }
                    }
                    if (!okay)
                    {
                        Log.debug("LAN Discovery: Bad magic");
                        continue;
                    }
                    if (bytes[MAGIC.Length] != Multiplayer.PROTOCOL_VERSION)
                    {
                        Log.debug("LAN Discovery: Bad protocol version (" + (int)bytes[MAGIC.Length] + " vs " + (int)Multiplayer.PROTOCOL_VERSION + ")");
                        continue;
                    }

                    Log.debug("LAN Discovery: Preparing and sending response");
                    byte[] portBytes = BitConverter.GetBytes(port);
                    byte[] nameBytes = Encoding.ASCII.GetBytes(name);
                    byte[] sendBack  = new byte[MAGIC.Length + portBytes.Length + nameBytes.Length];
                    Array.Copy(MAGIC, 0, sendBack, 0, MAGIC.Length);
                    Array.Copy(portBytes, 0, sendBack, MAGIC.Length, portBytes.Length);
                    Array.Copy(nameBytes, 0, sendBack, MAGIC.Length + portBytes.Length, nameBytes.Length);

                    other.Port = DEFAULT_PORT_RESPONSE;
                    UdpClient sendFrom = new UdpClient();
                    sendFrom.Send(sendBack, sendBack.Length, new IPEndPoint(IPAddress.Parse("10.0.2.15"), DEFAULT_PORT_RESPONSE));
                    sendFrom.Close();
                }
            }
            catch (Exception e)
            {
                if (e is SocketException && (((SocketException)e).Message.IndexOf("A blocking operation was interrupted") != -1 ||
                                             ((SocketException)e).Message.IndexOf("WSACancelBlockingCall") != -1))
                {
                    return;
                }
                Log.error("Exception during LAN discovery: " + e);
            }
            finally
            {
                if (client != null)
                {
                    client.Close();
                    client = null;
                }
            }
        }
Exemple #52
0
        /// <summary>
        /// Background thread handling all incoming traffic
        /// </summary>
        private void ReceivePackets()
        {
            while (true)
            {
                try
                {
                    // Get a datagram
                    receiveFrom = new IPEndPoint(IPAddress.Any, localPort);
                    // Stopwatch sw = new Stopwatch();
                    // sw.Start();
                    byte[] data = udpClientReceive.Receive(ref receiveFrom);
                    //if (sw.ElapsedMilliseconds > 10) { Console.WriteLine(sw.ElapsedMilliseconds); }
                    //sw.Stop();

                    // Decode the message
                    Stream         stream      = new MemoryStream(data);
                    IBencodingType receivedMsg = BencodingUtils.Decode(stream);
                    string         decoded     = BencodingUtils.ExtendedASCIIEncoding.GetString(data.ToArray());
                    //Log("Received message!");

                    // t is transaction id
                    // y is e for error, r for reply, q for query
                    if (receivedMsg is BDict) // throws error.. todo: fix
                    {
                        BDict dictMsg = (BDict)receivedMsg;
                        if (dictMsg.ContainsKey("y"))
                        {
                            if (dictMsg["y"].Equals(new BString("e")))
                            {
                                //Log("Received error! (ignored)");
                            }
                            else if (dictMsg["y"].Equals(new BString("r")))
                            {
                                // received reply
                                if (dictMsg.ContainsKey("r"))
                                {
                                    if (dictMsg["r"] is BDict)
                                    {
                                        BDict dictMsg2 = (BDict)dictMsg["r"];
                                        if (dictMsg2.ContainsKey("values"))
                                        {
                                            //Log("Received list of peers for torrent!");
                                            countRecvPeerPackets++;
                                        }
                                        else if (dictMsg2.ContainsKey("nodes"))
                                        {
                                            // could be an answer to find node or get peers
                                            //Log("Received list of nodeID & IP & port!");
                                            countRecvNodePackets++;
                                            BString nodeIDString = (BString)dictMsg2["nodes"];
                                            UpdateContactList(nodeIDString);
                                        }
                                        else
                                        {
                                            // no values and no nodes, assuming its a ping,
                                            // at least some form of response
                                        }
                                    }
                                    else
                                    {
                                    }
                                }
                            }
                            else if (dictMsg["y"].Equals(new BString("q")))
                            {
                                // received query
                                countRecvQuery++;
                                //Log("Received query! (ignored)");
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    //Log("Error receiving data: " + ex.ToString());
                }
            }
        }
Exemple #53
0
        static void Main(string[] args)
        {
            bool exit = false;

            while (!exit)
            {
                string myFileName = String.Format("{0}__{1}", DateTime.Now.ToString("yyyyMMddhhmmss"), "data" + ".txt");
                // string myFullPath = System.IO.Path.Combine("C:\\Users\\Tom.Maclean\\source\\repos\\XPlaneReader\\XPlaneReader", myFileName);
                string myFullPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, myFileName);

                byte[] data     = new byte[1024];
                string headings = "Time | N/A | N/A | N/A | N/A | N/A | N/A | _Vind,_kias | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | elev,stick | ailrn,stick | ruddr,stick | N/A | N/A | N/A | N/A | N/A | N/A | ___Q,rad/s | ___P,rad/s | ___R,rad/s | N/A | N/A | N/A | N/A | N/A | N/A | pitch,__deg | _roll,__deg | N/A | hding,__mag | N/A | N/A | N/A | N/A | N/A | N/A | _beta,__deg | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | __alt,ftmsl | N/A | N/A | N/A | N/A | N/A | N/A | thro1,_part | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | trq_1,ftlb | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | rpm_1,_prop | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | ptch1,__deg | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N1__1,_pcnt | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N2__1,_pcnt | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | FF_1,__galh | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | ITT_1,__deg | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | N/A | v-spd,__fpm | N/A | N/A | N/A | N/A | N/A | N/A |";

                System.IO.File.WriteAllText(myFullPath, headings);

                Console.WriteLine("X-Plane Data Read: \n");
                Console.WriteLine("Press any key to start recording \n\n");
                Console.ReadKey(true);

                // int i = 0

                // while (i < 10)
                while (Console.KeyAvailable == false)
                {
                    IPEndPoint ipep    = new IPEndPoint(IPAddress.Any, 49005);
                    UdpClient  newsock = new UdpClient(ipep);
                    IPEndPoint sender  = new IPEndPoint(IPAddress.Any, 49005);
                    data = newsock.Receive(ref sender);

                    for (int index = 5; index < data.Length; index++)   // Skip first five characters "DATA*"
                    {
                        // Console.Write("{0},", data[index]);
                    }

                    string DecimalToHex = BitConverter.ToString(data).Replace("-", "");    // Convert to hex output

                    using (System.IO.StreamWriter file = new System.IO.StreamWriter(myFullPath, true))
                    {
                        file.WriteLine("");
                    }

                    for (int index = 34; index < DecimalToHex.Length; index = index + 8) // Skip first five characters "DATA*" (10) and first two useless times (3*8)
                    {
                        string HexRep = DecimalToHex.Substring(index, 8);                //Convert to hex but now need to change from DCBA to ABCD

                        char[] phraseAsChars = HexRep.ToCharArray();
                        char[] endianChar    = new char[8];
                        endianChar[0] = phraseAsChars[6];
                        endianChar[1] = phraseAsChars[7];
                        endianChar[2] = phraseAsChars[4];
                        endianChar[3] = phraseAsChars[5];
                        endianChar[4] = phraseAsChars[2];
                        endianChar[5] = phraseAsChars[3];
                        endianChar[6] = phraseAsChars[0];
                        endianChar[7] = phraseAsChars[1];

                        string HexActual = new string(endianChar);

                        Int32 IntRep = Int32.Parse(HexActual, NumberStyles.AllowHexSpecifier);
                        // Integer to Byte[] and presenting it for float conversion
                        float f = BitConverter.ToSingle(BitConverter.GetBytes(IntRep), 0);
                        // There you go

                        using (System.IO.StreamWriter file = new System.IO.StreamWriter(myFullPath, true))
                        {
                            file.Write(f.ToString("N3"));
                            file.Write(" | ");
                        }

                        Console.Write("{0}", f);
                        Console.Write(" | ");
                    }

                    Console.Write("\n");
                    // i++;
                    newsock.Close();
                    Thread.Sleep(100);  // Wait 100ms (10 outputs per second)
                }

                Console.WriteLine("\n The file has been saved as:");
                Console.WriteLine(myFileName);
                Console.WriteLine("Press the spacebar to record again, or any other key to quit \n\n\n\n");
                Console.ReadKey(true);
                ConsoleKeyInfo checkQuit;
                checkQuit = Console.ReadKey(true);
                if (checkQuit.Key == ConsoleKey.Spacebar)
                {
                    exit = false;
                }
                else
                {
                    exit = true;
                }
            }
        }
Exemple #54
0
        public static byte[] ReceiveRaw()
        {
            IPEndPoint Sender = new IPEndPoint(IPAddress.Any, Port);

            return(UDP.Receive(ref Sender));
        }
Exemple #55
0
        private static void runClient()
        {
            try
            {
                IPEndPoint addr = new IPEndPoint(IPAddress.Any, DEFAULT_PORT_RESPONSE);
                client = new UdpClient();
                client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                client.Client.ExclusiveAddressUse = false;
                client.Client.Bind(addr);

                running = true;
                while (running)
                {
                    IPEndPoint other = null;
                    byte[]     bytes = client.Receive(ref other);
                    if (bytes.Length < MAGIC.Length + 5)
                    {
                        continue;
                    }
                    Log.debug("LAN Discovery: Received a response from " + other);

                    bool okay = true;
                    for (int i = 0; i < MAGIC.Length; ++i)
                    {
                        if (bytes[i] != MAGIC[i])
                        {
                            okay = false;
                            break;
                        }
                    }
                    if (!okay)
                    {
                        Log.debug("LAN Discovery: Bad magic");
                        continue;
                    }

                    Log.debug("LAN Discovery: Valid LAN discovery found.");

                    byte[] nameBytes = new byte[bytes.Length - MAGIC.Length - 4];
                    Array.Copy(bytes, MAGIC.Length + 4, nameBytes, 0, nameBytes.Length);
                    int    port = BitConverter.ToInt16(bytes, MAGIC.Length);
                    string name = Encoding.ASCII.GetString(nameBytes);
                    if (onDiscovery != null)
                    {
                        onDiscovery.Invoke(name, other, port);
                    }
                }
            }
            catch (Exception e)
            {
                if (e is SocketException && (((SocketException)e).Message.IndexOf("A blocking operation was interrupted") != -1 ||
                                             ((SocketException)e).Message.IndexOf("WSACancelBlockingCall") != -1))
                {
                    return;
                }
                Log.error("Exception during LAN discovery: " + e);
            }
            finally
            {
                if (client != null)
                {
                    client.Close();
                    client = null;
                }
            }
        }
Exemple #56
0
        public static void LRMStart(List <String[]> switchTables)
        {
            string received_data;

            byte[]   receive_byte_array;
            string[] returnvalues = null;
            string   label1       = null;
            string   label2       = null;
            string   port1        = null;
            string   port2        = null;
            string   connectionid = null;
            string   SNPPs        = null;

            try
            {
                while (true)
                {
                    receive_byte_array = listener.Receive(ref groupEP);
                    received_data      = Encoding.ASCII.GetString(receive_byte_array, 0, receive_byte_array.Length);
                    Router.RouterMain.WriteLine("LRM: Otrzymano:\t" + received_data);
                    string[] splitArray = received_data.Split('_');
                    //wiadomość od CC
                    if (splitArray[0].Equals("LinkConnectionRequest"))
                    {
                        connectionid = received_data.Split('*')[1];
                        SNPPs        = splitArray[1].Split('*')[0];
                        Thread lcr = new Thread(() =>
                        {
                            returnvalues = LinkConnectionRequest(splitArray[1].Split('*')[0], switchTables, labelpool, nextlrms);
                            label2       = returnvalues[0];
                            port1        = returnvalues[1];
                            port2        = returnvalues[2];
                            if (returnvalues.Length == 4)
                            {
                                label1 = returnvalues[3];
                            }

                            if (label1 != null && label2 != null)
                            {
                                LinkConnection(port1, label1, port2, label2, switchTables, connectionid);
                                label1 = null;
                                label2 = null;
                                port1  = null;
                                port2  = null;
                                Send("LinkConnectionRequestConfirm_" + routernumber + "*" + connectionid, ccport);
                                Router.RouterMain.WriteLine("LRM: Zestawiono połączenie nr " + connectionid);
                            }
                        });

                        lcr.Start();
                    }
                    //wiadomośc od CC (jeszcze nie gotowe)
                    else if (splitArray[0].Equals("LinkConnectionDeallocation"))
                    {
                        LinkConnectionDeallocation(switchTables, splitArray[1]);
                    }
                    //wiadomośc od wcześniejszego LRMa
                    else if (splitArray[0].Equals("LinkConnection"))
                    {
                        Send("LinkConnectionConfirmation", splitArray[2]);
                        Router.RouterMain.WriteLine("LRM: Wysłano potwierdzenie otrzymania wiadomości z etykietą " + splitArray[1] + " na port zwrotny " + splitArray[2]);
                        label1 = splitArray[1];
                    }
                    else if (splitArray[0].Equals("BreakConnection"))
                    {
                        Router.RouterMain.WriteLine("LRM: Zerwano połączenie pomiędzy interfejsem " + splitArray[1].Split('/')[1] + " routera " + splitArray[1].Split('.')[0] + " i interfejsem " + splitArray[2].Split('/')[1] + " routera " + splitArray[2].Split('.')[0] + ".");
                        Send(received_data, rcport);
                        Router.RouterMain.WriteLine("LRM: Wysłano informację o zerwanym łączu do RC na port " + rcport);
                        Send("BreakConnection_" + " " + "*" + connectionid, ccport);
                        Router.RouterMain.WriteLine("LRM: Wysłano informację o zerwanym łączu do CC na port " + ccport);
                        Send(received_data, "14099");
                    }
                    else if (splitArray[0].Equals("RestoreConnection"))
                    {
                        Router.RouterMain.WriteLine("LRM: Naprawiono połączenie pomiędzy interfejsem " + splitArray[1].Split('/')[1] + " routera " + splitArray[1].Split('.')[0] + " i interfejsem " + splitArray[2].Split('/')[1] + " routera " + splitArray[2].Split('.')[0] + ".");
                        Send(received_data, rcport);
                        Router.RouterMain.WriteLine("LRM: Wysłano informację o naprawionym łączu do RC na port " + rcport);
                        Send("RestoreConnection_" + " " + "*" + connectionid, ccport);
                        Router.RouterMain.WriteLine("LRM: Wysłano informację o naprawionym łączu do CC na port " + ccport);
                        Send(received_data, "14099");
                    }

                    //warunek pozwalający zestawić połączenie czyli dodać linijkę do tablicy komutacji
                    if (label1 != null && label2 != null)
                    {
                        LinkConnection(port1, label1, port2, label2, switchTables, connectionid);
                        label1 = null;
                        label2 = null;
                        port1  = null;
                        port2  = null;
                        Send("LinkConnectionRequestConfirm_" + routernumber + "*" + connectionid, ccport);
                        Router.RouterMain.WriteLine("LRM: Zestawiono połączenie nr " + connectionid);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
Exemple #57
0
        private void ListenForPackets()
        {
            while (true)
            {
                IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
                Byte[]     bytes            = null;
                try
                {
                    bytes = _udpClient.Receive(ref RemoteIpEndPoint);
                    BasicTunnelPacket packet = StandardUdpPacketFactory.instance.getPacket(bytes, RemoteIpEndPoint);
                    if (packet.type == BasicTunnelPacket.PKT_TYPE_WAVE_RS)
                    {
#if (DEBUG)
                        Logger.Debug("Got a wave response from " + packet.ip + ", my address is " +
                                     ((StandardWaveTunnelRsPacket)packet).externalEndPoint + "/" +
                                     ((StandardWaveTunnelRsPacket)packet).internalEndPoint);
#endif
                        ProcessWaveRs((StandardWaveTunnelRsPacket)packet);
                        Logger.Debug("Shutting down wave listener");
                        break;
                    }
                    else
                    {
                        Logger.Error("Waiting for a wave response, but got unknown packet");
                        break;
                    }
                }
                catch (SocketException e)
                {
#if (DEBUG)
                    Logger.Debug("Caught a socket exception [" + e.ErrorCode + "] : " + e.Message);
#endif
                    if (e.ErrorCode == 10004) // Interrupted
                    {
#if (DEBUG)
                        Logger.Debug("Socket has been interrupted, shutting down");
#endif
                        _udpClient.Close();
                        break;
                    }
                    else if (e.ErrorCode == 10054)
                    // Got ICMP connection closed ( we need to ignore this, hole punching causes these during init )
                    {
#if (DEBUG)
                        Logger.Debug("Remote host stated ICMP port closed, ignoring");
#endif
                    }
                    else
                    {
                        Logger.Warn("Caught a socket exception [" + e.ErrorCode +
                                    "], this looks spurious, ignoring : " + e.Message);
                        Logger.Error("Caught a socket exception [" + e.ErrorCode + "], shutting down read thread : " +
                                     e.Message);
                        _udpClient.Close();
                        break;
                    }
                }
                catch (ThreadAbortException e)
                {
#if DEBUG
                    Logger.Debug("Thread is aborting, closing : " + e.Message);
#endif
                    _udpClient.Close();
                    break;
                }
                catch (Exception e)
                {
                    Logger.Error("Exception while reading from UDP socket, shutting down read thread : " + e.Message, e);
                    // Most likely the link has failed (this side) or the app is closing
                    // either way, close the thread for the moment
                    _udpClient.Close();
                    break;
                }
            }
        }
Exemple #58
0
 private void StartSearching(object sender, RoutedEventArgs e)
 {
     if (searching != null && searching.IsAlive)
     {
         searching.Interrupt();
         udpSearching.Close();
         SearchBtn.Content = "Поиск...";
     }
     else
     {
         Devices.Items.Clear();
         searching = new Thread(() =>
         {
             try
             {
                 Dictionary <Tuple <int, String>, ServerInfo> ServerSet = new Dictionary <Tuple <int, String>, ServerInfo>();
                 udpSearching  = new UdpClient(Session.BroadcastingPort);
                 IPEndPoint ip = null;
                 while (true)
                 {
                     byte[] data    = udpSearching.Receive(ref ip);
                     string message = Encoding.UTF8.GetString(data);
                     Server server  = JsonConvert.DeserializeObject <Server>(message);
                     Tuple <int, String> serverTuple = new Tuple <int, string>(server.type, server.name);
                     if (!ServerSet.ContainsKey(serverTuple))
                     {
                         Thread searching2 = new Thread(() =>
                         {
                             try
                             {
                                 while (true)
                                 {
                                     foreach (Tuple <int, string> p in ServerSet.Keys.ToList())
                                     {
                                         if (ServerSet[p].value > 0)
                                         {
                                             ServerSet[p].value--;
                                         }
                                         Application.Current.Dispatcher.Invoke(new Action(() =>
                                         {
                                             if (ServerSet[p].value <= 0)
                                             {
                                                 ServerSet[p].lvi.Visibility = Visibility.Collapsed;
                                             }
                                             else if (ServerSet[p].lvi != null)
                                             {
                                                 ServerSet[p].lvi.Visibility = Visibility.Visible;
                                             }
                                         }));
                                     }
                                     Thread.Sleep(2000);
                                 }
                             }catch (ThreadInterruptedException _) { }
                         });
                         searching2.Start();
                         ServerInfo si = new ServerInfo();
                         Application.Current.Dispatcher.Invoke(new Action(() =>
                         {
                             StackPanel sp  = new StackPanel();
                             sp.Margin      = new Thickness(10);
                             sp.Orientation = Orientation.Horizontal;
                             PackIcon pi    = new PackIcon();
                             pi.Foreground  = new SolidColorBrush(Colors.White);
                             pi.Kind        = server.kind == 0 ? PackIconKind.Smartphone : PackIconKind.Computer;
                             pi.Height      = pi.Width = 40;
                             TextBlock tb   = new TextBlock();
                             tb.Text        = server.name + '\n' + Session.decodeType(server.type);
                             tb.Foreground  = new SolidColorBrush(Colors.White);
                             tb.FontSize    = 15;
                             tb.Padding     = new Thickness(10, 0, 0, 0);
                             sp.Children.Add(pi);
                             sp.Children.Add(tb);
                             ListViewItem lvi = new ListViewItem();
                             lvi.Content      = sp;
                             Devices.Items.Add(lvi);
                             si.lvi        = lvi;
                             lvi.Selected += delegate
                             {
                                 searching.Interrupt();
                                 searching2.Interrupt();
                                 udpSearching.Close();
                                 SearchBtn.Content           = "Поиск...";
                                 lvi.Visibility              = Visibility.Collapsed;
                                 SessionClient sessionClient = new SessionClient(ip.Address, server.port, server.type, server.mode);
                             };
                         }));
                         ServerSet.Add(serverTuple, si);
                     }
                     else
                     {
                         ServerSet[serverTuple].value = 5;
                     }
                 }
             }
             catch (System.Net.Sockets.SocketException) { }
         });
         searching.Start();
         SearchBtn.Content = "Остановить поиск";
     }
 }
Exemple #59
0
        private void ProcessDatagrams(object state)
        {
            UdpClient listener = (UdpClient)state;

            while (true)
            {
                // Check if we already closed the server
                if (listener.Client == null)
                {
                    return;
                }

                // WSAECONNRESET:
                // The virtual circuit was reset by the remote side executing a hard or abortive close.
                // The application should close the socket; it is no longer usable. On a UDP-datagram socket
                // this error indicates a previous send operation resulted in an ICMP Port Unreachable message.
                // Note the spocket settings on creation of the server. It makes us ignore these resets.
                IPEndPoint senderEndpoint = null;
                try
                {
                    //var result = listener.ReceiveAsync().Result;
                    //senderEndpoint = result.RemoteEndPoint;
                    //receiveBytes = result.Buffer;
                    Byte[] receiveBytes = listener.Receive(ref senderEndpoint);

                    Interlocked.Exchange(ref ServerInfo.AvailableBytes, listener.Available);
                    Interlocked.Increment(ref ServerInfo.NumberOfPacketsInPerSecond);
                    Interlocked.Add(ref ServerInfo.TotalPacketSizeIn, receiveBytes.Length);

                    if (receiveBytes.Length != 0)
                    {
                        _receiveThreadPool.QueueUserWorkItem(() =>
                        {
                            try
                            {
                                if (!GreylistManager.IsWhitelisted(senderEndpoint.Address) && GreylistManager.IsBlacklisted(senderEndpoint.Address))
                                {
                                    return;
                                }
                                if (GreylistManager.IsGreylisted(senderEndpoint.Address))
                                {
                                    return;
                                }
                                ProcessMessage(receiveBytes, senderEndpoint);
                            }
                            catch (Exception e)
                            {
                                Log.Warn($"Process message error from: {senderEndpoint.Address}", e);
                            }
                        });
                    }
                    else
                    {
                        Log.Warn("Unexpected end of transmission?");
                        continue;
                    }
                }
                catch (Exception e)
                {
                    Log.Error("Unexpected end of transmission?", e);
                    if (listener.Client != null)
                    {
                        continue;
                    }

                    return;
                }
            }
        }
    private void FuncRcvData()
    {
        client = new UdpClient (port);
        client.Client.ReceiveTimeout = 300; // msec
        client.Client.Blocking = false;
        while (stopThr == false) {
            try {
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = client.Receive(ref anyIP);
                string text = Encoding.ASCII.GetString(data);
                lastRcvd = text;

                if (lastRcvd.Length > 0) {
                    Thread.Sleep(delay_msec);
                    client.Send(data, data.Length, anyIP); // echo
                }
            }
            catch (Exception err)
            {
                //              print(err.ToString());
            }

            // without this sleep, on adnroid, the app will not start (freeze at Unity splash)
            Thread.Sleep(20); // 200
        }
        client.Close ();
    }