/// <summary> /// Handle Receive event for an UADP channel /// </summary> /// <param name="result"></param> private void OnReceive(IAsyncResult result) { try { // this is what had been passed into BeginReceive as the second parameter: UdpClient socket = result.AsyncState as UdpClient; // points towards whoever had sent the message: IPEndPoint source = new IPEndPoint(0, 0); // get the actual message and fill out the source: socket?.EndReceive(result, ref source); if (IsHostAddress(source.Address.ToString())) { //signal that uadp message was received from local ip m_shutdownEvent.Set(); return; } // schedule the next receive operation once reading is done: socket?.BeginReceive(new AsyncCallback(OnReceive), socket); } catch (Exception ex) { Assert.Warn(string.Format("OnReceive() failed due to the following reason: {0}", ex.Message)); } }
public void ReceiveCallback(IAsyncResult ar) { var endpoint = new IPEndPoint(MulticastAddress, Port); try { var receiveBytes = Client?.EndReceive(ar, ref endpoint); PacketReceived?.Invoke(this, receiveBytes); } catch (ObjectDisposedException) { if (isQuitting) { return; } } catch (Exception e) { Console.WriteLine(e); throw; } Console.WriteLine($"Endpoint: {endpoint}"); Client?.BeginReceive(ReceiveCallback, null); }
void ReceiveCallback(IAsyncResult ar) { try { UdpClient u = ((UdpState)ar.AsyncState).udpClient; IPEndPoint e = ((UdpState)ar.AsyncState).ipEndPoint; IAsyncResult r = ((UdpState)ar.AsyncState).result; byte[] receiveBytes = u?.EndReceive(ar, ref e); if (receiveBytes?.Length > 1) { RaiseDataReceived(DeCompress(receiveBytes)); } r = u?.BeginReceive(new AsyncCallback(ReceiveCallback), state); } catch (Exception e) { System.Diagnostics.Debug.WriteLine($"ReceiveCallback: {e.Message}"); } }
private void AsyncCallBackRecieve(IAsyncResult result) { byte[] received = _server.EndReceive(result, ref _address); _server.BeginReceive(new AsyncCallback(AsyncCallBackRecieve), null); string[] msg = Encoding.ASCII.GetString(received).Split('&'); // reply port / hostname / message / [connection data | ( new_connection | disconnected) client_address if (msg.Length >= 4 && msg[3].Equals("new_connection")) { newClient = new Client() { UserName = msg[1], ClientAddress = _address.Address, ClientPort = int.Parse(msg[0]), }; UpdateConnectedClients(newClient); } if (msg.Length >= 4 && msg[3].Equals("disconnecting")) { var message = $"Client disconnected\n{msg[2]} disconnected"; UpdateServerLog(message); } foreach (var client in listBoxConnectedClients.Items) { var refClient = client as Client; if (refClient != null && msg[0].Equals(refClient.ClientPort.ToString())) { continue; } var message = $"[{msg[1]}] {msg[2]}"; var buffer = Encoding.ASCII.GetBytes(message); // should be sending to refClient.ClientAddress _server.Send(buffer, buffer.Length, new IPEndPoint(refClient.ClientAddress, refClient.ClientPort)); } UpdateServerLog($"{msg[1]} : {msg[2]}"); }
private void Receive(IAsyncResult ar) { if (discoveryComplete) //Prevent ObjectDisposedException/NullReferenceException when the Close() function is called { return; } IPEndPoint ip = new IPEndPoint(IPAddress.Any, PORT_NUMBER); byte[] bytes = udp.EndReceive(ar, ref ip); var message = Encoding.ASCII.GetString(Messaging.SmartHomeProtocolEncoder.Decrypt(bytes)); var sys_info = ((dynamic)JObject.Parse(message)).system.get_sysinfo; TPLinkSmartDevice device = null; string model = (string)sys_info.model; if (model.StartsWith("HS110")) { device = new TPLinkSmartMeterPlug(ip.Address.ToString()); } else if (model.StartsWith("HS")) { device = new TPLinkSmartPlug(ip.Address.ToString()); } else if (model.StartsWith("LB")) { device = new TPLinkSmartBulb(ip.Address.ToString()); } if (device != null) { DiscoveredDevices.Add(device); } if (udp != null) { StartListening(); } }
private void RecvDataCallBack(IAsyncResult ar) { try { if (client != null) { RecvDatas.Add(client.EndReceive(ar, ref remoteEP)); } } catch (Exception ex) { //异常处理 Log.Error(ex, "RecvDataCallBack Error"); } finally { if (client != null) { client.BeginReceive(RecvDataCallBack, null); } } }
private void Receive(IAsyncResult res) { var groupEP = new IPEndPoint(IPAddress.Any, _port + 1); var data = _udpClient.EndReceive(res, ref groupEP); var packet = ToClass <Packet>(data); if (_enabled) { switch (packet.PacketType) { case 0: var telemetry = ToClass <sTelemetryData>(data); if (Telemetry != null) { Telemetry(telemetry); } break; case 1: var participantInfo = ToClass <sParticipantInfoStrings>(data); if (ParticipantInfoStrings != null) { ParticipantInfoStrings(participantInfo); } break; case 2: var additionalParticipantInfo = ToClass <sParticipantInfoStringsAdditional>(data); if (ParticipantInfoStringsAdditional != null) { ParticipantInfoStringsAdditional(additionalParticipantInfo); } break; } _udpClient.BeginReceive(new AsyncCallback(Receive), null); } }
static void Receive(IAsyncResult result) { lock (locker) { if (connection == null || result == null) { return; } IPEndPoint source = null; byte[] message = connection?.EndReceive(result, ref source); connection?.BeginReceive(new AsyncCallback(Receive), connection); if (source.Address.Equals(localhost)) { if (!portMap.ContainsKey(source)) { if (message[0] >= 242 && message[0] <= 244) { connection?.SendAsync(new byte[] { 244, Convert.ToByte((portMap[source] = MIDI.ConnectAbleton(244 - message[0])).Name.Substring(18)) }, 2, source); } } else if (message[0] < 128) { NoteOnMessage msg = new NoteOnMessage(Channel.Channel1, (Key)message[0], message[1]); portMap[source].NoteOn(null, in msg); } else if (message[0] == 245) { MIDI.Disconnect(portMap[source]); portMap.Remove(source); } else if (message[0] == 246 && Program.Project != null) { Program.Project.BPM = BitConverter.ToUInt16(message, 1); } } } }
/// <summary> /// This method continously listens for a reset command or a possible ipAddress to connect to /// </summary> /// <param name="result">The data that was recieved from the network</param> private void ReceiveData(IAsyncResult result) { IPEndPoint receiveIPGroup = new IPEndPoint(IPAddress.Any, NaviMobileManager.RemotePort); byte[] received; if (receiver != null) { received = receiver.EndReceive(result, ref receiveIPGroup); } else { return; } string message = Encoding.ASCII.GetString(received); if (message.Equals(RESET_STR)) { if (TransformManagerInterface.Instance != null) { TransformManagerInterface.Instance.Reset(); } } else { //assume that the message is an ipAddress byte error; if (naviConnectionID < 0) { if (!possibleConnections.Contains(message)) { possibleConnections.Add(message); //add ip to list } } } //start listening again receiver.BeginReceive(new AsyncCallback(ReceiveData), null); }
private static void UDPReceiveCallback(IAsyncResult _result) { try { IPEndPoint _clientEndPoint = new IPEndPoint(IPAddress.Any, 0); byte[] _data = udpListener.EndReceive(_result, ref _clientEndPoint); udpListener.BeginReceive(UDPReceiveCallback, null); Debug.Log("Pre lettura"); if (_data.Length < 4) { return; } using (Packet _packet = new Packet(_data)) { int _clientId = _packet.ReadInt(); if (_clientId == 0) { return; } if (clients[_clientId].udp.endPoint == null) { // If this is a new connection clients[_clientId].udp.Connect(_clientEndPoint); return; } if (clients[_clientId].udp.endPoint.ToString() == _clientEndPoint.ToString()) { // Ensures that the client is not being impersonated by another by sending a false clientID clients[_clientId].udp.HandleData(_packet); } } } catch (Exception _ex) { Debug.Log($"Error receiving UDP data: {_ex}"); } }
/// <summary> /// 当接收到回调 /// </summary> /// <param name="result">结果</param> private void OnReceiveCallBack(IAsyncResult result) { try { var receiveBytes = (listenEndPoint == null) ? client.Receive(ref listenEndPoint) : client.EndReceive(result, ref listenEndPoint); if (receiveBytes == null || receiveBytes.Length <= 0) { Dispose(); return; } receiveQueue.Push(receiveBytes); client.BeginReceive(OnReceiveCallBack, null); } catch (Exception) { Dispose(); } }
private static void UDPReceiveCallback(IAsyncResult ar) { try { IPEndPoint _clientEndPoint = new IPEndPoint(IPAddress.Any, 0); byte[] _data = UdpListener.EndReceive(ar, ref _clientEndPoint); UdpListener.BeginReceive(UDPReceiveCallback, null); if (_data.Length < 4) { return; } using (Packet packet = new Packet(_data)) { int _clientid = packet.ReadInt(); if (_clientid == 0) { return; } if (Clients[_clientid].udp.EndPoint == null) { Clients[_clientid].udp.Connect(_clientEndPoint); return; } if (Clients[_clientid].udp.EndPoint.ToString() == _clientEndPoint.ToString()) { Clients[_clientid].udp.HandleData(packet); } } } catch (Exception e) { Debug.Log($"Error receiving UDP data: {e}"); } }
private static void ReadCallbackUdp(IAsyncResult result) { if (_udpClientLisener != null) { try { IPEndPoint ep = (IPEndPoint)(result.AsyncState); byte[] receiveBytes = _udpClientLisener.EndReceive(result, ref ep); ReceivedData(receiveBytes, comStatus.OK); _udpClientLisener.BeginReceive(new AsyncCallback(ReadCallbackUdp), ep); } catch (Exception ex) { //MessageBox.Show(ex.Message); Close(); ConnectUdp(_hostIP, _hostPort, _localPort, true); //ReceivedData(new byte[0], comStatus.Close); } } }
private void ProbeReceived(IAsyncResult ar) { var remote = new IPEndPoint(IPAddress.Any, 0); var bytes = udp.EndReceive(ar, ref remote); // Compare beacon type to probe type var typeBytes = Encode(BeaconType); if (HasPrefix(bytes, typeBytes)) { // If true, respond again with our type, port and payload var responseData = Encode(BeaconType) .Concat(BitConverter.GetBytes((ushort)IPAddress.HostToNetworkOrder((short)AdvertisedPort))) .Concat(Encode(BeaconData)).ToArray(); udp.Send(responseData, responseData.Length, remote); } if (!Stopped) { udp.BeginReceive(ProbeReceived, null); } }
private void Receive(IAsyncResult ar) { var ip = new IPEndPoint(IPAddress.Any, 32414); try { _udp.EndReceive(ar, ref ip); if (_listeners.Add(ip.Address.ToString())) { StartListening(); } else { _listening = false; } } catch (Exception) { _listening = false; } }
private void ReceiveCallback(IAsyncResult result) { try { byte[] data = socket.EndReceive(result, ref endPoint); socket.BeginReceive(ReceiveCallback, null); if (data.Length < 4) { instance.Disconnect(); return; } HandleData(data); } catch (Exception ex) { Console.WriteLine($"UDP receive failed: {ex}"); Disconnect(); } }
private void RecvCallback(IAsyncResult ar) { recvState = null; UdpClient udp = (UdpClient)ar.AsyncState; IPEndPoint remoteEP = null; byte[] recvBytes = udp.EndReceive(ar, ref remoteEP); string recvText = ""; for (int i = 0; i < recvBytes.Length; i++) { recvText += recvBytes[i]; } tbx_RecvData.BeginInvoke(new Action <string>(RecvTextShow), recvText); if (udpClientSend == null) { udpClientSend = new UdpClient(); } udpClientSend.BeginSend(recvBytes, recvBytes.Length, remoteHost, remotePort, SendCallback, udpClientSend); }
void HandleReceive(System.IAsyncResult ar) { try { if (_udp == null) { return; } var clientEndpoint = new IPEndPoint(0, 0); byte[] receivedData = _udp.EndReceive(ar, ref clientEndpoint); _oscParser.FeedData(receivedData, receivedData.Length); while (_oscParser.MessageCount > 0) { lock (_received) { var msg = _oscParser.PopMessage(); Receive(new Capsule(msg, clientEndpoint)); } } } catch (Exception e) { RaiseError(e); } _udp.BeginReceive(_callback, null); }
private void ReceiveData(IAsyncResult result) { receiveIPGroup = new IPEndPoint(IPAddress.Any, remotePort); byte[] received; if (receiver != null) { received = receiver.EndReceive(result, ref receiveIPGroup); } else { return; } string receivedString = Encoding.ASCII.GetString(received); ipAddress = receivedString; hasReceivedMessage = true; isReceiving = false; receiver.Close(); receiver = null; Debug.Log("Broadcast received! Stopped listening for broadcast"); }
private void OnConnection(IAsyncResult result) { try { byte[] data = udpClient.EndReceive(result, ref ipEndPoint); // Start listening for next connection again udpClient.BeginReceive(OnConnection, null); if (data.Length < sizeof(int)) { connectionToServer.Disconnect(); return; } HandlePacketData(data); } catch { connectionToServer.Disconnect(); } }
private void ReceiveCallback(IAsyncResult result) { try { byte[] data = Socket.EndReceive(result, ref EndPoint); Socket.BeginReceive(ReceiveCallback, null); if (data.Length < 4) { Instance.Disconnect(); return; } HandleData(data); } catch (System.ObjectDisposedException) { Disconnect(); } catch (Exception e) { Debug.Log($"Error receiving data via UDP: {e}"); Disconnect(); } }
private static void UDPReceiveCallback(IAsyncResult _result) { try { IPEndPoint _clientEndPoint = new IPEndPoint(IPAddress.Any, 0); byte[] _data = udpListener.EndReceive(_result, ref _clientEndPoint); udpListener.BeginReceive(UDPReceiveCallback, null); if (_data.Length < 4) { return; } using (Packet _packet = new Packet(_data)) { int _clientId = _packet.ReadInt(); if (_clientId == 0) { return; } if (clients[_clientId].udp.endPoint == null) { clients[_clientId].udp.Connect(_clientEndPoint); return; } if (clients[_clientId].udp.endPoint.ToString() == _clientEndPoint.ToString()) { clients[_clientId].udp.HandleData(_packet); } } } catch (Exception _ex) { Console.WriteLine($"Error receiving UDP data: {_ex}"); } }
private void HandleClientPacketReceived(IAsyncResult result) { if (CommsCallback != null) { IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 3007); byte[] dataBytes = _client.EndReceive(result, ref endPoint); string data = Encoding.ASCII.GetString(dataBytes, 0, dataBytes.Length).Trim('\0'); Android.Util.Log.Debug("Leda", "Received: " + data); if ((data.IndexOf(Game_Identifier) > -1) && (data.IndexOf(string.Concat("&id=", MyID)) < 0)) { Android.Util.Log.Debug("Leda", "Sent"); DecodeAndSendData(data); } } if (_clientOpen) { _client.BeginReceive(HandleClientPacketReceived, _client); } }
private void ReceiveCallback(IAsyncResult AR) { try { byte[] data = socket.EndReceive(AR, ref endPoint); socket.BeginReceive(ReceiveCallback, null); if (data.Length < 4) { Client client = GameObject.FindObjectOfType <Client>(); client.Disconnect(); return; } HandleData(data); } catch (Exception e) { Disconnect(); } }
public void Run() { stop = false; var ep = new IPEndPoint(IPAddress.Any, 0); Console.WriteLine("Listening on port " + port.ToString()); while (!stop && udp.Client.IsBound) { var asyn = udp.BeginReceive((ar) => { var data = udp.EndReceive(ar, ref ep); ThreadPool.QueueUserWorkItem(clientThread, new Tuple <IPEndPoint, byte[]>(ep, data)); }, null); if (!asyn.AsyncWaitHandle.WaitOne(waitTimeout)) { Console.WriteLine("Timeout - no package received during the last {0} seconds!\nShutting down!", waitTimeout / 1000); Stop(); break; } } }
private void Receive(IAsyncResult asyncResult) { try { var remote = new IPEndPoint(IPAddress.Any, 0); byte[] buffer = _udp.EndReceive(asyncResult, ref remote); if (buffer != null && buffer.Length > 0 && Protocol.TryDecodeProbeMessage(buffer, out string remoteId) && Message.ServiceId.Equals(remoteId)) { byte[] response = Protocol.Encode(Message); _udp.Send(response, response.Length, remote); } _udp.BeginReceive(Receive, null); } catch (ObjectDisposedException) { // Normal behavior of UdpClient/Socket to throw when closed. } }
void OnReceive(IAsyncResult ar) { try { DataReceived dataReceived = new DataReceived(); dataReceived.data = connection.EndReceive(ar, ref dataReceived.ipEndPoint); connection.BeginReceive(OnReceive, null); Debug.Log("OnReceive: " + dataReceived.data); lock (handler) { dataReceivedQueue.Enqueue(dataReceived); } } catch (SocketException e) { // This happens when a client disconnects, as we fail to send to that port. UnityEngine.Debug.LogError("[UdpConnection] " + e.Message); } }
private static void UDPReceiveCallback(IAsyncResult result) { try { IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Any, 0); byte[] data = _udpListener.EndReceive(result, ref clientEndPoint); _udpListener.BeginReceive(UDPReceiveCallback, null); if (data.Length < 4) { return; } using (Packet packet = new Packet(data)) { int clientId = packet.ReadInt(); if (clientId == 0) { return; } if (clients[clientId].udp.endPoint == null) { clients[clientId].udp.Connect(clientEndPoint); return; } if (clients[clientId].udp.endPoint.ToString() == clientEndPoint.ToString()) { clients[clientId].udp.HandleData(packet); } } } catch (Exception e) { Log($"Error receiving UDP data: {e}"); } }
public void ReceiveCallback_LocalSurface(IAsyncResult ar) { Byte[] receiveBytes = _udpClient_LocalSurface.EndReceive(ar, ref _anyIP_LocalSurface); string result = System.Text.Encoding.UTF8.GetString(receiveBytes); print("message received: " + result); if (SurfaceMessage.isMessage(result)) { print("is surface"); _surface = new SurfaceRectangle(result); Debug.Log("surface: " + _surface.ToString()); _udpClient_LocalSurface.Close(); } else { _udpClient_LocalSurface.BeginReceive(new AsyncCallback(this.ReceiveCallback_LocalSurface), null); } }
void OnPingBack(IAsyncResult result) { try { IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0); ServerInfo si = result.AsyncState as ServerInfo; UdpClient c = si.client; byte[] data = c.EndReceive(result, ref RemoteIpEndPoint); if (data.Length == 3 && data[0] == 11 && data[2] == 1) // server info pkg and free slots { var time = DateTime.Now - si.pingSent; si.ping = (int)time.TotalMilliseconds; si.gameMode = data[1]; AppendToServerList(si); } c.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
/// <summary> /// Asynchronously listens on the given client for a single packet. /// </summary> public static void Receive(UdpClient Client, ReceiveRawPacketHandler OnReceive) { // Good job Microsoft, for making this so easy O_O while (true) { try { Client.BeginReceive(delegate(IAsyncResult ar) { lock (Client) { IPEndPoint end = new IPEndPoint(IPAddress.Any, 0); byte[] data; try { data = Client.EndReceive(ar, ref end); OnReceive(end, data); } catch (SocketException se) { if (se.SocketErrorCode == SocketError.Shutdown) { return; } if (_CanIgnore(se)) { Receive(Client, OnReceive); } else { throw se; } } catch (ObjectDisposedException) { return; } } }, null); return; } catch (SocketException se) { if (!_CanIgnore(se)) { throw se; } } catch (ObjectDisposedException) { return; } } }
// Actually builds, sends, sets the received bytes and returns the whole packet private EDNSPacket SendUdpNetworkPacket(string sDNSIP, string sIPToResolve, int nPort, byte bType, bool bEDNS, byte[] bMachine_ID) { // Create empty EDNS packet EDNSPacket Packet = new EDNSPacket(); try { IPEndPoint Endpoint = new IPEndPoint(IPAddress.Parse(sDNSIP), nPort); // Send the current machine_id host if (bEDNS) Packet.CreateEDNSPacketMachineID(sIPToResolve, bType, bMachine_ID); else Packet.CreateDNSPacket(sIPToResolve, bType); if (Packet.GetPacketLen() > 0) { // Create a udp client to send the packet UdpClient udpGo = new UdpClient(); udpGo.Client.SendTimeout = 2000; udpGo.Client.ReceiveTimeout = 2000; udpGo.Send(Packet.GetPacket(), Packet.GetPacket().Length, Endpoint); //IPEndPoint object will allow us to read datagrams sent from any source. IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0); // Launch Asynchronous IAsyncResult iarResult = udpGo.BeginReceive(null, null); // Wait until complete bool bKill = false; DateTime dtTimeStart = DateTime.Now; while (iarResult.IsCompleted == false) { // Sleep instead of cycling System.Threading.Thread.Sleep(100); // Watchdog, if doesn't return in 5 seconds get out if (dtTimeStart.AddSeconds(5) < DateTime.Now) { bKill = true; break; } } // This can hang when not happy about a broken connection if (bKill) udpGo.Close(); else Packet.SetReceivePacket(udpGo.EndReceive(iarResult, ref RemoteIpEndPoint)); } } catch (Exception Ex) { // TODO: Log an exception? } // Always just return packet return Packet; }