static void Main() { var sk = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); EndPoint my = new IPEndPoint(IPAddress.Loopback,1233); sk.BeginReceiveFrom(new byte[1500], 0, 1500, SocketFlags.None, ref my, new AsyncCallback(ReceiveCallback), null); sk.Close(); }
private static void StartReceivingDataV6() { if (socketV6 == null) { return; } try { EndPoint endPoint = anyEndPointV6; socketV6?.BeginReceiveFrom(receiveBufferV6, 0, MaxUDPPacketSize, SocketFlags.None, ref endPoint, OnReceivedDataV6, socketV6); } catch (ObjectDisposedException) { // We can ignore this exception, because this means that we are closing down. } catch (Exception ex) { Log.LogErrorException(ex); if (socketV6 != null) { socketV6.Close(); socketV6 = null; } } }
public void StartListeningBroadcast(int port = 42424) { try { StopListeningBroadcast(); _mainUdpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); _mainUdpSocket.EnableBroadcast = true; _mainUdpSocket.Bind(new IPEndPoint(IPAddress.Any, port)); var stateObj = new StateObject(_mainUdpSocket); EndPoint clientEp = new IPEndPoint(IPAddress.Any, 0); _mainUdpSocket?.BeginReceiveFrom(stateObj.buffer, 0, stateObj.buffer.Length, SocketFlags.None, ref clientEp, new AsyncCallback(ReceiveBroadcastCallback), stateObj); } catch (ObjectDisposedException) { _gameLogger.Error("Client StartListeningBroadcast: socket has been closed"); } catch (SocketException se) { _gameLogger.Error($"Client StartListeningBroadcast, socket: {se.ErrorCode}, {se.SocketErrorCode}"); } catch (Exception e) { _gameLogger.Error($"Client StartListeningBroadcast, unexpected: {e.Message}"); } }
public UDPClient(string serverIP) { //Paquete sendData = new Paquete (); //sendData.id = 0; //sendData.identificadorPaquete = Paquete.Identificador.conectar; entrantPackagesCounter = 0; sendingPackagesCounter = 0; //Creamos conexion this.clientSocket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //Inicializamos IP del servidor try{ IPAddress ipServer = IPAddress.Parse (serverIP); IPEndPoint server = new IPEndPoint (ipServer, 30001); epServer = (EndPoint)server; //Debug.Log("Enviando data de inicio de conexion: "); //string data = sendData.GetDataStream(); //byte[] dataBytes = GetBytes (data); //Enviar solicitud de conexion al servidor //clientSocket.BeginSendTo (dataBytes,0,dataBytes.Length,SocketFlags.None,epServer,new System.AsyncCallback(this.SendData),null); // Inicializando el dataStream this.dataStream = new byte[1024]; // Empezamos a escuhar respuestas del servidor clientSocket.BeginReceiveFrom(this.dataStream, 0, this.dataStream.Length, SocketFlags.None, ref epServer, new AsyncCallback(this.ReceiveData), null); } catch(FormatException e){ throw e; } catch(SocketException e){ throw e; } }
public UDPServer() { try { // Iniciando array de clientes conectados this.listaClientes = new ArrayList(); entrantPackagesCounter = 0; sendingPackagesCounter = 0; // Inicializando el delegado para actualizar estado //this.updateStatusDelegate = new UpdateStatusDelegate(this.UpdateStatus); // Inicializando el socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); // Inicializar IP y escuhar puerto 30000 IPEndPoint server = new IPEndPoint(IPAddress.Any, 30001); // Asociar socket con el IP dado y el puerto serverSocket.Bind(server); // Inicializar IPEndpoint de los clientes IPEndPoint clients = new IPEndPoint(IPAddress.Any, 0); // Inicializar Endpoint de clientes EndPoint epSender = (EndPoint)clients; // Empezar a escuhar datos entrantes serverSocket.BeginReceiveFrom(this.dataStream, 0, this.dataStream.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender); } catch (Exception ex) { //Debug.Log("Error al cargar servidor: " + ex.Message+ " ---UDP "); } }
public void Receive() { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); Logging.Debug($"++++++Receive Server Port, size:" + _buffer.Length); _remote?.BeginReceiveFrom(_buffer, 0, _buffer.Length, 0, ref remoteEndPoint, new AsyncCallback(RecvFromCallback), null); }
public void StartReceive() { if (receiveSocket != null) StopReceive(); receiveSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); bindEndPoint = new IPEndPoint(IPAddress.Any, 3001); recBuffer = new byte[maxBuffer]; receiveSocket.Bind(bindEndPoint); receiveSocket.BeginReceiveFrom(recBuffer, 0, recBuffer.Length, SocketFlags.None, ref bindEndPoint, new AsyncCallback(MessageReceivedCallback), (object)this); }
public void Initialize(String _remoteIp, int _remotePort, int _localPort) { Debug.Log ("UAC CTOR"); localPort = _localPort; remoteIp = _remoteIp; remotePort = _remotePort; //Setup the socket and message buffer udpSock = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); udpSock.Bind (new IPEndPoint (IPAddress.Any, localPort)); buffer = new byte[1024]; //Start listening for a new message. EndPoint newClientEP = new IPEndPoint (IPAddress.Any, 0); udpSock.BeginReceiveFrom (buffer, 0, buffer.Length, SocketFlags.None, ref newClientEP, DoReceiveFrom, udpSock); }
public void StartReceive() { try { if (receiveSocket != null) StopReceive(); receiveSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); bindEndPoint = new IPEndPoint(IPAddress.Any, 3002); recBuffer = new byte[maxBuffer]; receiveSocket.Bind(bindEndPoint); receiveSocket.BeginReceiveFrom(recBuffer, 0, recBuffer.Length, SocketFlags.None, ref bindEndPoint, new AsyncCallback(MessageReceivedCallback), (object)this); } catch (SocketException ex) { System.Diagnostics.Debug.WriteLine(String.Format("StartReceive SocketException: {0} ", ex.Message)); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(String.Format("StartReceive Exception: {0} ", ex.Message)); } }
public SocketUdpServer(IPAddress address, bool dualMode, out int port) { _server = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp); if (dualMode) { _server.DualMode = dualMode; } port = _server.BindToAnonymousPort(address); IPAddress remoteAddress = address.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any; EndPoint remote = new IPEndPoint(remoteAddress, 0); _server.BeginReceiveFrom(new byte[1], 0, 1, SocketFlags.None, ref remote, Received, null); }
private void Receive(System.IAsyncResult ar) { EndPoint ipe = new IPEndPoint(IPAddress.IPv6Any, 0); byte[] data = null; PacketType msgid = (PacketType)(-1); Packet packet = null; try { int num = listener.EndReceiveFrom(ar, ref ipe); if (num >= 4) { data = new byte[num]; Buffer.BlockCopy(m_Buffer, 0, data, 0, num); if (BitConverter.ToInt32(data, 0) == data.Length - 4) { packet = new Packet(ipe, data, null); msgid = packet.BeginRead(); packet.ResetPosition(); } } EndPoint remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0); listener.BeginReceiveFrom(m_Buffer, 0, m_Buffer.Length, SocketFlags.None, ref remoteEP, Receive, listener); if (packet == null) { return; } } catch (SocketException e) { DebugMessage("Server Close On Receive:" + e.ToString()); Close(); return; } catch (Exception e) { DebugMessage("Receive:" + e.ToString()); EndPoint remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0); listener.BeginReceiveFrom(m_Buffer, 0, m_Buffer.Length, SocketFlags.None, ref remoteEP, Receive, listener); return; } lock (OnListenClient) { if (OnListenClient.ContainsKey((EndPoint)packet.peer)) { OnListenClient[(EndPoint)packet.peer].Add(packet); return; } } if (msgid > PacketType.SendAllowTypeTop && msgid < PacketType.SendAllowTypeEnd && ToPeer.ContainsKey((EndPoint)packet.peer)) { PushPacket(packet); lock (checklock) { clientcheck[(EndPoint)packet.peer] = true; } } else { switch (msgid) { case PacketType.ON_CONNECT: { ListenClient(packet); break; } case PacketType.CONNECTION_LOST: { if (ToPeer.ContainsKey((EndPoint)packet.peer)) { packet.BeginRead(); SendData sendData = packet.ReadSendData(""); PushPacket(PacketType.CONNECTION_LOST, sendData.DebugMessage, packet.peer); } packet.CloseStream(); break; } case PacketType.P2P_SERVER_CALL: { if (ToPeer.ContainsKey((EndPoint)packet.peer)) { packet.BeginRead(); SendData sendData = packet.ReadSendData(SocketToKey[packet.peer]); string remoteendpoint = (string)((object[])sendData.Parameters)[0]; string localendpoint = (string)((object[])sendData.Parameters)[1]; object thedata = ((object[])sendData.Parameters)[2]; if (remoteendpoint != packet.peer.ToString() && ToPeer.TryGetValue(TraceRoute.IPEndPointParse(remoteendpoint, AddressFamily.InterNetworkV6), out PeerBase peer)) { ((object[])sendData.Parameters)[0] = packet.peer.ToString(); ((object[])sendData.Parameters)[1] = remoteendpoint; using (Packet sendpacket = new Packet(peer.socket)) { sendpacket.BeginWrite(PacketType.P2P_SERVER_CALL); sendpacket.WriteSendData(sendData, SocketToKey[TraceRoute.IPEndPointParse(remoteendpoint, AddressFamily.InterNetworkV6)], EncryptAndCompress.LockType.AES); Send(sendpacket, peer.socket); } //DebugMessage(((Client.P2PCode)sendData.Code).ToString() + ":" + packet.peer.ToString() + " to " + remoteendpoint.ToString()); } else { ((object[])sendData.Parameters)[1] = packet.peer.ToString(); using (Packet sendpacket = new Packet(packet.peer)) { sendpacket.BeginWrite(PacketType.P2P_SERVER_FAILED); sendpacket.WriteSendData(sendData, SocketToKey[packet.peer], EncryptAndCompress.LockType.AES); Send(sendpacket, packet.peer); } } } packet.CloseStream(); break; } case PacketType.P2P_GET_PUBLIC_ENDPOINT: { using (Packet sendpacket = new Packet(packet.peer)) { sendpacket.BeginWrite(PacketType.P2P_GET_PUBLIC_ENDPOINT); sendpacket.WriteSendData(new SendData(0, packet.peer.ToString()), "", EncryptAndCompress.LockType.None); Send(sendpacket, packet.peer); } packet.CloseStream(); break; } case PacketType.CHECK: { if (ToPeer.ContainsKey((EndPoint)packet.peer)) { lock (checklock) { clientcheck[(EndPoint)packet.peer] = true; } } packet.CloseStream(); break; } case PacketType.ClientDebugMessage: { if (ToPeer.ContainsKey((EndPoint)packet.peer)) { packet.BeginRead(); SendData sendData = packet.ReadSendData(SocketToKey[packet.peer]); DebugMessage("ClientDebugMessage:" + packet.peer.ToString() + " " + sendData.DebugMessage); } packet.CloseStream(); break; } default: { DebugMessage(msgid.ToString()); //PushPacket(PacketType.CONNECTION_LOST, "不正確的標頭資訊 Receive", packet.peer); packet.CloseStream(); break; } } } }
private void AsyncBeginReceive() { // allocate a packet buffer //WrappedObject<UDPPacketBuffer> wrappedBuffer = Pool.CheckOut(); UDPPacketBuffer buf = new UDPPacketBuffer(); if (!m_shutdownFlag) { try { // kick off an async read m_udpSocket.BeginReceiveFrom( //wrappedBuffer.Instance.Data, buf.Data, 0, UDPPacketBuffer.BUFFER_SIZE, SocketFlags.None, ref buf.RemoteEndPoint, AsyncEndReceive, //wrappedBuffer); buf); } catch (SocketException e) { if (e.SocketErrorCode == SocketError.ConnectionReset) { MainConsole.Instance.Warn( "[UDPBASE]: SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + m_udpPort); bool salvaged = false; while (!salvaged) { try { m_udpSocket.BeginReceiveFrom( //wrappedBuffer.Instance.Data, buf.Data, 0, UDPPacketBuffer.BUFFER_SIZE, SocketFlags.None, ref buf.RemoteEndPoint, AsyncEndReceive, //wrappedBuffer); buf); salvaged = true; } catch (SocketException) { } catch (ObjectDisposedException) { return; } } MainConsole.Instance.Warn("[UDPBASE]: Salvaged the UDP listener on port " + m_udpPort); } } catch (ObjectDisposedException) { } } }
public void Receive() { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); _remote.BeginReceiveFrom(_buffer, 0, _buffer.Length, 0, ref remoteEndPoint, new AsyncCallback(RecvFromCallback), null); }
private void ReceiveData(IAsyncResult asyncResult) { try { byte[] data; Packet receivedData = new Packet(serverDataStream); Packet sendData = new Packet(); IPEndPoint clients = new IPEndPoint(IPAddress.Any, 0); EndPoint epSender = (EndPoint)clients; serverSocket.EndReceiveFrom(asyncResult, ref epSender); //Debug.WriteLine(epSender); sendData.ChatDataIdentifier = receivedData.ChatDataIdentifier; // Username/password split switch (receivedData.ChatDataIdentifier) { case DataIdentifier.LogIn: string[] userPassAux = new string[2]; userPassAux = receivedData.ChatName.Split(':'); receivedData.ChatName = userPassAux[0]; clientPass = userPassAux[1]; if (!MySqlVerifyClient(receivedData.ChatName, clientPass, epSender.ToString(), mySqlConnection)) { sendData.ChatDataIdentifier = receivedData.ChatDataIdentifier = DataIdentifier.FLogIn; sendData.ChatName = receivedData.ChatName; sendData.ChatMessage = "Username or Password Incorrect"; } data = sendData.GetDataStream(); serverSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, epSender, new AsyncCallback(SendData), epSender); serverSocket.BeginReceiveFrom(serverDataStream, 0, serverDataStream.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender); break; case DataIdentifier.SignUp: if (!MySqlExistentUser(receivedData.ChatName, mySqlConnection)) { ClientInfo info = new ClientInfo(); string[] infoStr = new string[5]; infoStr = receivedData.ChatMessage.Split('%'); clientPass = infoStr[0]; info.firstName = infoStr[1]; info.lastName = infoStr[2]; info.mail = infoStr[3]; info.phone = infoStr[4]; MySqlAddClient(receivedData.ChatName, clientPass, epSender.ToString(), mySqlConnection, info.firstName, info.lastName, info.mail, info.phone); } else { sendData.ChatDataIdentifier = DataIdentifier.FSignUp; } sendData.ChatName = receivedData.ChatName; data = sendData.GetDataStream(); serverSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, epSender, new AsyncCallback(SendData), epSender); serverSocket.BeginReceiveFrom(serverDataStream, 0, serverDataStream.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender); break; default: sendData.ChatName = receivedData.ChatName; switch (receivedData.ChatDataIdentifier) { case DataIdentifier.Message: sendData.ChatMessage = string.Format("{0} : {1}", receivedData.ChatName, receivedData.ChatMessage); break; case DataIdentifier.Online: Client client = new Client(); client.endPoint = epSender; client.name = receivedData.ChatName; clientList.Add(client); sendData.ChatMessage = string.Format("- {0} is online -", receivedData.ChatName); break; case DataIdentifier.LogOut: foreach (Client c in clientList) { if (c.endPoint.Equals(epSender)) { clientList.Remove(c); break; } } sendData.ChatMessage = string.Format("- {0} has gone offline -", receivedData.ChatName); break; } data = sendData.GetDataStream(); foreach (Client c in clientList) { if (c.endPoint != epSender || sendData.ChatDataIdentifier != DataIdentifier.Online) { serverSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, c.endPoint, new AsyncCallback(SendData), c.endPoint); } } serverSocket.BeginReceiveFrom(serverDataStream, 0, serverDataStream.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender); Invoke(updateStatusDelegate, new object[] { sendData.ChatMessage }); break; } } catch (Exception ex) { MessageBox.Show("ReceiveData Error: " + ex.Message, "UDP Server", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
protected virtual void ConnectWork() { try { if (_Url != null) { bool isMulticastOrBroadcast = false; int port = 0; Uri uri = new Uri(_Url); port = uri.Port; var addresses = Dns.GetHostAddresses(uri.DnsSafeHost); if (addresses != null && addresses.Length > 0) { var address = addresses[0]; if (address.AddressFamily == AddressFamily.InterNetwork) { if (address.Equals(IPAddress.Broadcast)) { isMulticastOrBroadcast = true; } else { var firstb = address.GetAddressBytes()[0]; if (firstb >= 224 && firstb < 240) { isMulticastOrBroadcast = true; } } } else if (address.AddressFamily == AddressFamily.InterNetworkV6) { if (address.IsIPv6Multicast) { isMulticastOrBroadcast = true; } } _Socket = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp); if (isMulticastOrBroadcast) { _Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true); if (address.AddressFamily == AddressFamily.InterNetworkV6) { #if NET_STANDARD_2_0 || NET_4_6 // Notice: it is a pitty that unity does not support ipv6 multicast. (Unity 5.6) _Socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership, new IPv6MulticastOption(address)); _Socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.MulticastTimeToLive, 5); #endif _Socket.Bind(new IPEndPoint(IPAddress.IPv6Any, 0)); } else { if (!address.Equals(IPAddress.Broadcast)) { _Socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(address, IPAddress.Any)); _Socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 5); } _Socket.Bind(new IPEndPoint(IPAddress.Any, 0)); } _BroadcastEP = new IPEndPoint(address, port); } else { _Socket.Connect(address, port); } } } if (_Socket != null) { if (_PreStart != null) { _PreStart(this); } byte[] receivebuffer = new byte[CONST.MTU]; int receivecnt = 0; EndPoint broadcastRespEP; if (_BroadcastEP != null && _BroadcastEP.AddressFamily == AddressFamily.InterNetworkV6) { broadcastRespEP = new IPEndPoint(IPAddress.IPv6Any, 0); } else { broadcastRespEP = new IPEndPoint(IPAddress.Any, 0); } Action BeginReceive = () => { if (_BroadcastEP != null) { _Socket.BeginReceiveFrom(receivebuffer, 0, CONST.MTU, SocketFlags.None, ref broadcastRespEP, ar => { try { receivecnt = _Socket.EndReceiveFrom(ar, ref broadcastRespEP); } catch (Exception e) { if (IsConnectionAlive) { _ConnectWorkCanceled = true; PlatDependant.LogError(e); } } _HaveDataToSend.Set(); }, null); } else { _Socket.BeginReceive(receivebuffer, 0, CONST.MTU, SocketFlags.None, ar => { try { receivecnt = _Socket.EndReceive(ar); } catch (Exception e) { if (IsConnectionAlive) { _ConnectWorkCanceled = true; PlatDependant.LogError(e); } } _HaveDataToSend.Set(); }, null); } }; if (_OnReceive != null) { BeginReceive(); } while (!_ConnectWorkCanceled) { if (_OnReceive != null) { if (receivecnt > 0) { if (_BroadcastEP != null && _WaitForBroadcastResp) { _OnReceive(receivebuffer, receivecnt, broadcastRespEP); receivecnt = 0; BeginReceive(); } else { if (_BroadcastEP != null) { _Socket.Connect(broadcastRespEP); _BroadcastEP = null; } _OnReceive(receivebuffer, receivecnt, _Socket.RemoteEndPoint); receivecnt = 0; BeginReceive(); } } } if (!HoldSending) { BufferInfo binfo; while (_PendingSendMessages.TryDequeue(out binfo)) { var message = binfo.Buffer; int cnt = binfo.Count; if (_OnSend != null && _OnSend(message, cnt)) { if (_OnSendComplete != null) { _OnSendComplete(message, true); } } else { SendRaw(message, cnt, success => { if (_OnSendComplete != null) { _OnSendComplete(message, success); } }); } } } if (_OnUpdate != null) { _OnUpdate(this); } var waitinterval = _UpdateInterval; var easeratio = _EaseUpdateRatio; if (waitinterval > 0 && easeratio > 0) { var easeinterval = waitinterval * easeratio; if (_LastSendTick + easeinterval <= System.Environment.TickCount) { waitinterval = easeinterval; } } _HaveDataToSend.WaitOne(waitinterval); } } } catch (ThreadAbortException) { Thread.ResetAbort(); } catch (Exception e) { PlatDependant.LogError(e); } finally { _ConnectWorkRunning = false; _ConnectWorkCanceled = false; if (_PreDispose != null) { _PreDispose(this); } if (_Socket != null) { _Socket.Close(); _Socket = null; } // set handlers to null. _OnReceive = null; _OnSend = null; _OnSendComplete = null; _OnUpdate = null; _PreDispose = null; } }
public void StartListening() { m_signalStop = false; m_endPoint = new IPEndPoint(IPAddress.Any, 0); m_socket.BeginReceiveFrom(m_buffer, 0, m_buffer.Length, 0, ref m_endPoint, new AsyncCallback(_onBeginRecieve), m_socket); }
/// <summary> /// This function performs the actual ping. It sends the ping packets created to /// the destination and posts the async receive operation to receive the response. /// Once a ping is sent, it waits for the receive handler to indicate a response /// was received. If not it times out and indicates this to the user. /// </summary> public void DoPing() { // If the packet hasn't already been built, then build it. Console.WriteLine("In DoPing() method, do the pinging..."); Console.WriteLine(); if (protocolHeaderList.Count == 0) { BuildPingPacket(); } Console.WriteLine("Pinging {0} with {1} bytes of data ", destEndPoint.Address.ToString(), pingPayloadLength); try { // Post an async receive first to ensure we receive a response to the echo request // in the event of a low latency network. pingSocket.BeginReceiveFrom( receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, ref castResponseEndPoint, receiveCallback, this ); // Keep track of how many outstanding async operations there are Interlocked.Increment(ref pingOutstandingReceives); // Send an echo request and wait for the response while (pingCount > 0) { Interlocked.Decrement(ref pingCount); // Increment the sequence count in the ICMP header if (destEndPoint.AddressFamily == AddressFamily.InterNetwork) { icmpHeader.Sequence = (ushort)(icmpHeader.Sequence + (ushort)1); // Build the byte array representing the ping packet. This needs to be done // before ever send because we change the sequence number (which will affect // the calculated checksum). pingPacket = icmpHeader.BuildPacket(protocolHeaderList, pingPayload); } else if (destEndPoint.AddressFamily == AddressFamily.InterNetworkV6) { icmpv6EchoRequestHeader.Sequence = (ushort)(icmpv6EchoRequestHeader.Sequence + (ushort)1); // Build the byte array representing the ping packet. This needs to be done // before ever send because we change the sequence number (which will affect // the calculated checksum). pingPacket = icmpv6Header.BuildPacket(protocolHeaderList, pingPayload); } // Mark the time we sent the packet pingSentTime = DateTime.Now; // Send the echo request pingSocket.SendTo(pingPacket, destEndPoint); // Wait for the async handler to indicate a response was received if (pingReceiveEvent.WaitOne(pingReceiveTimeout, false) == false) { // timeout occurred Console.WriteLine("Request timed out."); } else { // Reset the event pingReceiveEvent.Reset(); } // Sleep for a short time before sending the next request Thread.Sleep(1000); } } catch (SocketException err) { Console.WriteLine("Socket error occurred: {0}", err.Message); throw; } }
public static void startUDPListening() { try { //We are using UDP sockets serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPAddress ip = IPAddress.Parse(InventoryMSystem.staticClass.strServerIP); IPEndPoint ipEndPoint = new IPEndPoint(ip, InventoryMSystem.staticClass.iServePort); // IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, port); //Bind this address to the server serverSocket.Bind(ipEndPoint); //防止客户端强行中断造成的异常 long IOC_IN = 0x80000000; long IOC_VENDOR = 0x18000000; long SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12; byte[] optionInValue = { Convert.ToByte(false) }; byte[] optionOutValue = new byte[4]; serverSocket.IOControl((int)SIO_UDP_CONNRESET, optionInValue, optionOutValue); IPEndPoint ipeSender = new IPEndPoint(IPAddress.Any, 0); //The epSender identifies the incoming clients EndPoint epSender = (EndPoint)ipeSender; //Start receiving data serverSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref epSender, new AsyncCallback(OnReceive), epSender); //TcpListener server = null; //try //{ // // Set the TcpListener on port 13000. // //IPAddress localAddr = IPAddress.Parse("127.0.0.1"); // IPAddress localAddr = IPAddress.Parse("192.168.36.168"); // // TcpListener server = new TcpListener(port); // server = new TcpListener(localAddr, port); // // Start listening for client requests. // server.Start(); // // Buffer for reading data // Byte[] bytes = new Byte[256]; // String data = null; // // Enter the listening loop. // while (true) // { // Console.Write("Waiting for a connection... "); // // Perform a blocking call to accept requests. // // You could also user server.AcceptSocket() here. // TcpClient client = server.AcceptTcpClient(); // Console.WriteLine("Connected!"); // data = null; // // Get a stream object for reading and writing // NetworkStream stream = client.GetStream(); // int i; // // Loop to receive all the data sent by the client. // while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) // { // // Translate data bytes to a ASCII string. // data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); // Debug.WriteLine("Received: {0}", data); // // Process the data sent by the client. // data = data.ToUpper(); // byte[] msg = System.Text.Encoding.ASCII.GetBytes(data); // // Send back a response. // stream.Write(msg, 0, msg.Length); // Debug.WriteLine("Sent: {0}", data); // } // // Shutdown and end connection // client.Close(); // } //} //catch (SocketException e) //{ // Console.WriteLine("SocketException: {0}", e); //} //finally //{ // // Stop listening for new clients. // server.Stop(); //} //********************************************************************** } catch (Exception ex) { Debug.WriteLine( string.Format("UDPServer.startUDPListening -> error = {0}" , ex.Message)); } }
private void button2_Click(object sender, EventArgs e) { Form5 frm5 = new Form5(this); frm5.ShowDialog(this); try { sckt.Bind(epLocal); sckt.Connect(epRemote); byte[] buffer = new byte[1024]; sckt.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref epRemote, new AsyncCallback(MessageCallBack), buffer); if (keyGen == true) { RSA = new RSACryptoServiceProvider(keySize); myPublicKey = RSA.ExportParameters(false); myPrivateKey = RSA.ExportParameters(true); TextWriter writer = new StreamWriter(".\\myPublicKey.xml"); string publicKey = RSA.ToXmlString(false); writer.Write(publicKey); writer.Dispose(); TextWriter writer2 = new StreamWriter(".\\myPrivateKey.xml"); string privateKey = RSA.ToXmlString(true); writer2.Write(privateKey); writer2.Dispose(); System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding(); byte[] msg = new byte[1024]; msg = enc.GetBytes(RSA.ToXmlString(false)); sckt.Send(msg); } if (keyGen == false) { RSA = new RSACryptoServiceProvider(); RSA.FromXmlString(filePrivateKey); myPrivateKey = RSA.ExportParameters(true); TextWriter writer = new StreamWriter(".\\myPrivateKey.xml"); string privateKey = RSA.ToXmlString(true); writer.Write(privateKey); writer.Close(); RSA.FromXmlString(filePublicKey); myPublicKey = RSA.ExportParameters(false); writer = new StreamWriter(".\\myPublicKey.xml"); string publicKey = RSA.ToXmlString(false); writer.Write(publicKey); writer.Close(); RSA.FromXmlString(fileForeignKey); foreignPublicKey = RSA.ExportParameters(false); writer = new StreamWriter(".\\foreignPublicKey.xml"); string publicKeyXML = RSA.ToXmlString(false); writer.Write(publicKeyXML); writer.Close(); msgCounter = 2; } button1.Enabled = true; szyfrowanieToolStripMenuItem.Enabled = true; } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
/// <summary> /// Method used in <see cref="_receiverTask"/> to receive Netbios Name Service packets /// </summary> /// <returns>Task that completes when the <see cref="_receiverTask"/> stops receiving packets</returns> private async Task Receive() { var buffer = new byte[RECEIVE_BUFFER_SIZE]; EndPoint localEndPoint = new IPEndPoint(0, 0); while (true) { var tcs = new TaskCompletionSource <EndPoint>(); try { _socket.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref localEndPoint, asynchronousResult => { var t = (TaskCompletionSource <EndPoint>)asynchronousResult.AsyncState; EndPoint ep = new IPEndPoint(0, 0); try { _socket.EndReceiveFrom(asynchronousResult, ref ep); t.TrySetResult(ep); } catch (Exception) { t.TrySetResult(null); } }, tcs); } catch (Exception) { if (_endReceive.Task.IsCompleted) { return; } continue; } // Wait until a new packet has been received or NbNsClient is disposed if (await Task.WhenAny(tcs.Task, _endReceive.Task) == _endReceive.Task) { return; } // RemoteEndPoint is null when there was an exception in EndReceive. In that case, discard the packet. var remoteEndPoint = (await tcs.Task) as IPEndPoint; if (remoteEndPoint == null) { continue; } // If we cannot parse the received packet, discard it. NbNsPacketBase packet; if (!NbNsPacketBase.TryParse(buffer, out packet)) { continue; } // If the received packet is the response to a known request, set the request task result to the received packet. var identifier = new PacketIdentifier(packet.Header.NameTrnId, remoteEndPoint.Address); TaskCompletionSource <NbNsPacketBase> result; if (_pendingUnicastRequests.TryGetValue(identifier, out result)) { result.TrySetResult(packet); } } }
private void OnReceive(IAsyncResult ar) { try { EndPoint receivedFromEP = new IPEndPoint(IPAddress.Any, 0); //Get the IP from where we got a message. clientSocket.EndReceiveFrom(ar, ref receivedFromEP); //Convert the bytes received into an object of type Data. Data msgReceived = new Data(byteData); //Act according to the received message. switch (msgReceived.cmdCommand) { //We have an incoming call. case Command.Invite: { if (bIsCallActive == false) { //We have no active call. //Ask the user to accept the call or not. if (MessageBox.Show("Call coming from " + msgReceived.strName + ".\r\n\r\nAccept it?", "VoiceChat", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { SendMessage(Command.OK, receivedFromEP); vocoder = msgReceived.vocoder; otherPartyEP = receivedFromEP; otherPartyIP = (IPEndPoint)receivedFromEP; InitializeCall(); VideoCall(); } else { //Now when The call is declined we Send a busy response to the client. SendMessage(Command.Busy, receivedFromEP); } } else { //Even if We already have an existing call then also we Send a busy response. SendMessage(Command.Busy, receivedFromEP); } break; } //OK is received in response to an Invite. case Command.OK: { Thread init = new Thread(new ThreadStart(InitializeCall)); init.IsBackground = true; init.Start(); VideoCall(); // WriteImage.Start(); // Thread testthread = new Thread(new ThreadStart(VideoCall)); // testthread.IsBackground = true; // testthread.Start(); // VideoCall(); break; } //The destination is busy. case Command.Busy: { MessageBox.Show("User busy.", "VoiceChat", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); break; } case Command.Bye: { if (receivedFromEP.Equals(otherPartyEP) == true) { //End the call. UninitializeCall(); } break; } } byteData = new byte[1024]; //Get ready to receive more commands. clientSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref receivedFromEP, new AsyncCallback(OnReceive), null); } catch (Exception ex) { MessageBox.Show(ex.Message, "VoiceChat-OnReceive ()", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void VoiceInitialization() { try { device = new Device(); device.SetCooperativeLevel(this, CooperativeLevel.Normal); CaptureDevicesCollection captureDeviceCollection = new CaptureDevicesCollection(); DeviceInformation deviceInfo = captureDeviceCollection[0]; capture = new Capture(deviceInfo.DriverGuid); short channels = 1; //Stereo. short bitsPerSample = 16; //we can either use 8 or 16. int samplesPerSecond = 22050; //11KHz will use 11025 , 22KHz will use 22050, 44KHz use 44100 etc. //The waveformat which has to be captured is set here. waveFormat = new WaveFormat(); waveFormat.Channels = channels; waveFormat.FormatTag = WaveFormatTag.Pcm; waveFormat.SamplesPerSecond = samplesPerSecond; waveFormat.BitsPerSample = bitsPerSample; waveFormat.BlockAlign = (short)(channels * (bitsPerSample / (short)8)); waveFormat.AverageBytesPerSecond = waveFormat.BlockAlign * samplesPerSecond; captureBufferDescription = new CaptureBufferDescription(); captureBufferDescription.BufferBytes = waveFormat.AverageBytesPerSecond / 5; captureBufferDescription.Format = waveFormat; playbackBufferDescription = new BufferDescription(); playbackBufferDescription.BufferBytes = waveFormat.AverageBytesPerSecond / 5; playbackBufferDescription.Format = waveFormat; playbackBuffer = new SecondaryBuffer(playbackBufferDescription, device); bufferSize = captureBufferDescription.BufferBytes; bIsCallActive = false; nUdpClientFlag = 0; //Using UDP sockets clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); EndPoint ourEP = new IPEndPoint(IPAddress.Any, 1450); //Listen asynchronously on port 1450 for coming messages (Invite, Bye, etc). clientSocket.Bind(ourEP); //Receive data from any IP. EndPoint remoteEP = (EndPoint)(new IPEndPoint(IPAddress.Any, 0)); byteData = new byte[1024]; //Here we use technique to receive data asynchronously. clientSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref remoteEP, new AsyncCallback(OnReceive), null); } catch (Exception ex) { MessageBox.Show(ex.Message, "dangerVoiceChat-Initialize ()", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void OnReceive(IAsyncResult ar) { try { IPEndPoint ipeSender = new IPEndPoint(IPAddress.Any, 0); EndPoint epSender = (EndPoint)ipeSender; serverSocket.EndReceiveFrom(ar, ref epSender); //Transform the array of bytes received from the user into an //intelligent form of object Data Data msgReceived = new Data(byteData); //We will send this object in response the users request Data msgToSend = new Data(); byte [] message; //If the message is to login, logout, or simple text message //then when send to others the type of the message remains the same msgToSend.cmdCommand = msgReceived.cmdCommand; msgToSend.strName = msgReceived.strName; switch (msgReceived.cmdCommand) { case Command.Login: //When a user logs in to the server then we add her to our //list of clients ClientInfo clientInfo = new ClientInfo(); clientInfo.endpoint = epSender; clientInfo.strName = msgReceived.strName; clientList.Add(clientInfo); //Set the text of the message that we will broadcast to all users msgToSend.strMessage = "<<<" + msgReceived.strName + " has joined the room>>>"; break; case Command.Logout: //When a user wants to log out of the server then we search for her //in the list of clients and close the corresponding connection int nIndex = 0; foreach (ClientInfo client in clientList) { if (client.endpoint == epSender) { clientList.RemoveAt(nIndex); break; } ++nIndex; } msgToSend.strMessage = "<<<" + msgReceived.strName + " has left the room>>>"; break; case Command.Message: //Set the text of the message that we will broadcast to all users msgToSend.strMessage = msgReceived.strName + ": " + msgReceived.strMessage; break; case Command.List: //Send the names of all users in the chat room to the new user msgToSend.cmdCommand = Command.List; msgToSend.strName = null; msgToSend.strMessage = null; //Collect the names of the user in the chat room foreach (ClientInfo client in clientList) { //To keep things simple we use asterisk as the marker to separate the user names msgToSend.strMessage += client.strName + "*"; } message = msgToSend.ToByte(); //Send the name of the users in the chat room serverSocket.BeginSendTo(message, 0, message.Length, SocketFlags.None, epSender, new AsyncCallback(OnSend), epSender); break; } if (msgToSend.cmdCommand != Command.List) //List messages are not broadcasted { message = msgToSend.ToByte(); foreach (ClientInfo clientInfo in clientList) { if (clientInfo.endpoint != epSender || msgToSend.cmdCommand != Command.Login) { //Send the message to all users serverSocket.BeginSendTo(message, 0, message.Length, SocketFlags.None, clientInfo.endpoint, new AsyncCallback(OnSend), clientInfo.endpoint); } } txtLog.Text += msgToSend.strMessage + "\r\n"; } //If the user is logging out then we need not listen from her if (msgReceived.cmdCommand != Command.Logout) { //Start listening to the message send by the user serverSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref epSender, new AsyncCallback(OnReceive), epSender); } } catch (Exception ex) { MessageBox.Show(ex.Message, "SGSServerUDP", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void Listen(int Port) { socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); try { socket.Bind(new IPEndPoint(IPAddress.Parse("0"), Port)); socket.BeginReceiveFrom(ReceiveBuffer, 0, ReceiveBuffer.Length, SocketFlags.None, ref RemoteEP, new AsyncCallback(ReceiveFrom_Callback), socket); } catch { if (OnBindFail != null) { OnBindFail(); } } }
private IAsyncResult BeginRecvFrom(AsyncCallback callback, object state) { var result = _socket.BeginReceiveFrom(_buffer, 0, ushort.MaxValue, SocketFlags.None, ref _remoteEP, callback, state); return(result); }
private static void ReceiveData(IAsyncResult result) { System.Text.Encoding iso = System.Text.Encoding.GetEncoding("iso8859-1"); string dataReceived = ""; string[] msgTokens; try { AsyncCallback AcceptReceive = new AsyncCallback(ReceiveData); IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort); EndPoint tempRemoteEP = (EndPoint)RemoteIpEndPoint; int numBytes = soUdp.EndReceiveFrom(result, ref tempRemoteEP); dataReceived = iso.GetString(received); msgTokens = dataReceived.Split(new char[1] { '!' }); try { log.InfoFormat("MSG_FROM_DRV: {0} {1}", msgTokens[0], msgTokens[1].ToString().TrimEnd(new char[] { '\0' })); Console.WriteLine("MSG_FROM_DRV: {0} {1}", msgTokens[0], msgTokens[1].ToString().TrimEnd(new char[] { '\0' })); Vehicle myVehicle = new Vehicle(msgTokens[0]); // init vehicle using MID string switch ((MsgDrvType)Enum.Parse(typeof(MsgDrvType), msgTokens[1])) { case MsgDrvType.ARRIVE: log.InfoFormat("Msg ARRIVE {0}", msgTokens[1].ToString().TrimEnd(new char[] { '\0' })); myVehicle.ConfirmArrive(); break; case MsgDrvType.DEPART: log.InfoFormat("Msg DEPART {0}", msgTokens[1].ToString().TrimEnd(new char[] { '\0' })); myVehicle.ConfirmDepart(); break; case MsgDrvType.SEND_ALL: log.InfoFormat("Msg REQ_ALL {0}", msgTokens[1].ToString().TrimEnd(new char[] { '\0' })); myVehicle.GetAllStops(); break; default: break; } } catch (Exception exc) { log.ErrorFormat("Problem with MSG_FROM_DRV: {0}", exc.Message); } finally { soUdp.BeginReceiveFrom(received, 0, received.Length, SocketFlags.None, ref tempRemoteEP, AcceptReceive, null); } } catch (Exception exc) { log.InfoFormat("Error on UDP socket {0}", exc.Message); } }
public Form5(FlowLayoutPanel fl, string str1, string str2, string str3, string str4) { InitializeComponent(); listMessages.Hide(); textBox1.Hide(); textBox3.Hide(); button1.Hide(); button2.Hide(); button3.Hide(); button4.Hide(); button5.Hide(); hSet1 = new HashSet <int>(index1); hSet2 = new HashSet <int>(index2); hSet3 = new HashSet <int>(index3); hSet4 = new HashSet <int>(index4); hSet5 = new HashSet <int>(index5); hSet6 = new HashSet <int>(index6); hSet7 = new HashSet <int>(index7); hSet8 = new HashSet <int>(index8); hSet9 = new HashSet <int>(index9); hSet10 = new HashSet <int>(index10); hSet11 = new HashSet <int>(index11); hSet12 = new HashSet <int>(index12); int n = 25; for (int i = 1; i <= n; i++) { Control[] c = fl.Controls.Find(i.ToString(), false); flowLayoutPanel1.Controls.Add(c[0]); } this.my_ip = str1; this.my_port = str2; this.friend_ip = str3; this.friend_port = str4; // MessageBox.Show(my_ip + " " + my_port + " " + friend_ip + " " + friend_port); //set up socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); //get user IP //textRemortIP.Text = GetLocalIP(); my_ip = GetLocalIP(); try { epLocal = new IPEndPoint(IPAddress.Parse(my_ip), Convert.ToInt32(my_port.Length)); sck.Bind(epLocal); //connecting to remort IP epRemort = new IPEndPoint(IPAddress.Parse(friend_ip), Convert.ToInt32(friend_port.Length)); sck.Connect(epRemort); //Listning to specific port buffer = new byte[1500]; sck.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref epRemort, new AsyncCallback(MessageCallBack), buffer); } catch (Exception ex) { MessageBox.Show("Can't connect"); return; } //MessageBox.Show("Connected"); //MessageBox.Show(flowLayoutPanel1.Size.ToString()); }
static void ProcessMeshSignal(IAsyncResult result) { _meshSignalSocket.BeginReceiveFrom(_signal, 0, 128, SocketFlags.None, ref _ep, new AsyncCallback(Program.ProcessMeshSignal), new object()); }
public void NetworkTargetUdpTest() { var target = new NetworkTarget() { Address = "udp://127.0.0.1:3002", Layout = "${message}\n", KeepConnection = true, }; string expectedResult = string.Empty; using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) { Exception receiveException = null; var receivedMessages = new List <string>(); var receiveFinished = new ManualResetEvent(false); byte[] receiveBuffer = new byte[4096]; listener.Bind(new IPEndPoint(IPAddress.Loopback, 3002)); EndPoint remoteEndPoint = null; AsyncCallback receivedDatagram = null; receivedDatagram = result => { try { int got = listener.EndReceiveFrom(result, ref remoteEndPoint); string message = Encoding.UTF8.GetString(receiveBuffer, 0, got); lock (receivedMessages) { receivedMessages.Add(message); if (receivedMessages.Count == 100) { receiveFinished.Set(); } } remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); listener.BeginReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, ref remoteEndPoint, receivedDatagram, null); } catch (Exception ex) { receiveException = ex; } }; remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); listener.BeginReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, ref remoteEndPoint, receivedDatagram, null); target.Initialize(new LoggingConfiguration()); int pendingWrites = 100; var writeCompleted = new ManualResetEvent(false); var exceptions = new List <Exception>(); AsyncContinuation writeFinished = ex => { lock (exceptions) { exceptions.Add(ex); pendingWrites--; if (pendingWrites == 0) { writeCompleted.Set(); } } }; int toWrite = pendingWrites; for (int i = 0; i < toWrite; ++i) { var ev = new LogEventInfo(LogLevel.Info, "logger1", "message" + i).WithContinuation(writeFinished); target.WriteAsyncLogEvent(ev); expectedResult += "message" + i + "\n"; } Assert.IsTrue(writeCompleted.WaitOne(10000, false)); target.Close(); Assert.IsTrue(receiveFinished.WaitOne(10000, false)); Assert.AreEqual(toWrite, receivedMessages.Count); for (int i = 0; i < toWrite; ++i) { Assert.IsTrue(receivedMessages.Contains("message" + i + "\n"), "Message #" + i + " not received."); } Assert.IsNull(receiveException, "Receive exception: " + receiveException); } }
public IAsyncResult BeginReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP, AsyncCallback callback, object state) { return(m_ClientSocket.BeginReceiveFrom(buffer, offset, size, socketFlags, ref remoteEP, callback, state)); }
/// <summary> /// Begin an asynchronous receive of the next bit of raw data /// </summary> protected virtual void BeginReceive() { m_socket.BeginReceiveFrom( RecvBuffer, 0, RecvBuffer.Length, SocketFlags.None, ref reusedEpSender, ReceivedData, null); }
private void ReceiveData(IAsyncResult asyncResult) { try { Packet receivedData = new Packet(this.dataStream); IPEndPoint clients = new IPEndPoint(IPAddress.Any, 0); EndPoint epSender = (EndPoint)clients; serverSocket.EndReceiveFrom(asyncResult, ref epSender); switch (receivedData.ChatDataIdentifier) { case DataIdentifier.Message: DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Data)); MemoryStream ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes(receivedData.ChatMessage)); Data draw = (Data)js.ReadObject(ms); x = Convert.ToInt32(draw.X * kWidth); y = Convert.ToInt32(draw.Y * kHeight); x0 = Convert.ToInt32(draw.X0 * kWidth); y0 = Convert.ToInt32(draw.Y0 * kHeight); cx = Convert.ToInt32(draw.Cx * kWidth); cy = Convert.ToInt32(draw.Cy * kHeight); Pen pen = new Pen(Color.Blue); pen.Width = draw.PenSize; pen.Color = draw.Color; switch (draw.DrawMode) { case 1: { graphics.DrawLine(pen, x0, y0, x, y); break; } case 2: { graphics.DrawEllipse(pen, x0, y0, cx, cy); break; } case 3: { if (cx >= 0 && cy >= 0) { graphics.DrawRectangle(pen, x0, y0, cx, cy); } else if (cx >= 0 && cy <= 0) { graphics.DrawRectangle(pen, x0, y0 + cy, cx, -1 * cy); } else if (cx <= 0 && cy >= 0) { graphics.DrawRectangle(pen, x0 + cx, y0, -1 * cx, cy); } else if (cx <= 0 && cy <= 0) { graphics.DrawRectangle(pen, x0 + cx, y0 + cy, -1 * cx, -1 * cy); } break; } case 4: { SolidBrush Brush = new SolidBrush(draw.Color); if (cx >= 0 && cy >= 0) { graphics.FillRectangle(Brush, x0, y0, cx, cy); } else if (cx >= 0 && cy <= 0) { graphics.FillRectangle(Brush, x0, y0 + cy, cx, -1 * cy); } else if (cx <= 0 && cy >= 0) { graphics.FillRectangle(Brush, x0 + cx, y0, -1 * cx, cy); } else if (cx <= 0 && cy <= 0) { graphics.FillRectangle(Brush, x0 + cx, y0 + cy, -1 * cx, -1 * cy); } break; } case 5: { SolidBrush Brush = new SolidBrush(draw.Color); graphics.FillEllipse(Brush, x0, y0, cx, cy); break; } case 6: { ////////////// break; } } IntPtr desktopDC = GetDC(IntPtr.Zero); Graphics g = Graphics.FromHdc(desktopDC); g.DrawImage(bitmap, 0, 0); g.Dispose(); ReleaseDC(desktopDC); ms.Close(); break; } serverSocket.BeginReceiveFrom(this.dataStream, 0, this.dataStream.Length, SocketFlags.None, ref epSender, new AsyncCallback(this.ReceiveData), epSender); } catch (Exception ex) { MessageBox.Show("ReceiveData Error: " + ex.Message, "UDP Server", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void BeginReceiveFrom_Helper(IPAddress listenOn, IPAddress connectTo, bool expectedToTimeout = false) { using (Socket serverSocket = new Socket(SocketType.Dgram, ProtocolType.Udp)) { serverSocket.ReceiveTimeout = 500; int port = serverSocket.BindToAnonymousPort(listenOn); EndPoint receivedFrom = new IPEndPoint(connectTo, port); IAsyncResult async = serverSocket.BeginReceiveFrom(new byte[1], 0, 1, SocketFlags.None, ref receivedFrom, null, null); // Behavior difference from Desktop: receivedFrom will _not_ change during the synchronous phase. // IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint; // Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily); // Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address); SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port); bool success = async.AsyncWaitHandle.WaitOne(expectedToTimeout ? Configuration.FailingTestTimeout : Configuration.PassingTestTimeout); if (!success) { throw new TimeoutException(); } receivedFrom = new IPEndPoint(connectTo, port); int received = serverSocket.EndReceiveFrom(async, ref receivedFrom); Assert.Equal(1, received); Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint)); IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint; Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily); Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address); } }
private void ReceiveCallback(IAsyncResult ar) { SSUSession session = null; try { EndPoint ep = RemoteEP; var size = MySocket.EndReceiveFrom(ar, ref ep); if (ep.AddressFamily != AddressFamily.InterNetwork && (!SessionLayer.RouterContext.Inst.UseIpV6 || ep.AddressFamily != AddressFamily.InterNetworkV6)) { return; // TODO: Add IPV6 } if (size <= 37) { Logging.LogDebugData($"SSU Recv: {size} bytes [0x{size:X}] from {ep} (hole punch, ignored)"); return; } var sessionendpoint = (IPEndPoint)ep; Logging.LogDebugData($"SSU Recv: {size} bytes [0x{size:X}] from {ep}"); lock ( Sessions ) { if (!Sessions.ContainsKey(sessionendpoint)) { if (IPFilter.IsFiltered(((IPEndPoint)ep).Address)) { Logging.LogTransport($"SSUHost ReceiveCallback: IPAddress {sessionendpoint} is blocked. {size} bytes."); return; } ++IncommingConnectionAttempts; Logging.LogTransport($"SSUHost: incoming connection " + $"from {sessionendpoint} created."); session = new SSUSession( this, Send, (IPEndPoint)ep, MyRouterContext); Sessions[sessionendpoint] = session; Logging.LogTransport($"SSUHost: incoming connection " + $"{session.DebugId} from {sessionendpoint} created."); NeedCpu(session); ConnectionCreated?.Invoke(session); } else { session = Sessions[sessionendpoint]; } } var localbuffer = BufRefLen.Clone(ReceiveBuf, 0, size); #if DEBUG Stopwatch Stopwatch1 = new Stopwatch(); Stopwatch1.Start(); #endif try { session.Receive(localbuffer); } catch (ThreadAbortException taex) { AddFailedSession(session); Logging.Log(taex); } catch (ThreadInterruptedException tiex) { AddFailedSession(session); Logging.Log(tiex); } catch (ChecksumFailureException cfex) { AddFailedSession(session); Logging.Log(cfex); } catch (SignatureCheckFailureException scex) { AddFailedSession(session); Logging.Log(scex); } catch (FailedToConnectException fcex) { AddFailedSession(session); #if LOG_MUCH_TRANSPORT Logging.LogTransport(fcex); #endif if (session != null) { NetDb.Inst.Statistics.FailedToConnect(session.RemoteRouterIdentity.IdentHash); session.RaiseException(fcex); } } #if DEBUG Stopwatch1.Stop(); if (Stopwatch1.ElapsedMilliseconds > SessionCallWarningLevelMilliseconds) { Logging.LogTransport( $"SSUHost ReceiveCallback: WARNING Session {session} used {Stopwatch1.ElapsedMilliseconds}ms cpu."); } #endif } catch (Exception ex) { AddFailedSession(session); Logging.Log(ex); if (session != null && session.RemoteRouterIdentity != null && NetDb.Inst != null) { NetDb.Inst.Statistics.DestinationInformationFaulty(session.RemoteRouterIdentity.IdentHash); session.RaiseException(ex); } } finally { RemoteEP = LocalEP; MySocket.BeginReceiveFrom(ReceiveBuf, 0, ReceiveBuf.Length, SocketFlags.None, ref RemoteEP, new AsyncCallback(ReceiveCallback), MySocket); } }
[Fact] // Base case // "The supplied EndPoint of AddressFamily InterNetwork is not valid for this Socket, use InterNetworkV6 instead." public void Socket_BeginReceiveFromV4IPEndPointFromV4Client_Throws() { Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp); socket.DualMode = false; EndPoint receivedFrom = new IPEndPoint(IPAddress.Loopback, UnusedPort); Assert.Throws<ArgumentException>(() => { socket.BeginReceiveFrom(new byte[1], 0, 1, SocketFlags.None, ref receivedFrom, null, null); }); }
private void BeginReceiveFrom_Helper(IPAddress listenOn, IPAddress connectTo) { using (Socket serverSocket = new Socket(SocketType.Dgram, ProtocolType.Udp)) { serverSocket.ReceiveTimeout = 500; int port = serverSocket.BindToAnonymousPort(listenOn); EndPoint receivedFrom = new IPEndPoint(connectTo, port); IAsyncResult async = serverSocket.BeginReceiveFrom(new byte[1], 0, 1, SocketFlags.None, ref receivedFrom, null, null); IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint; Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily); Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address); SocketUdpClient client = new SocketUdpClient(serverSocket, connectTo, port); bool success = async.AsyncWaitHandle.WaitOne(500); if (!success) { throw new TimeoutException(); } receivedFrom = new IPEndPoint(connectTo, port); int received = serverSocket.EndReceiveFrom(async, ref receivedFrom); Assert.Equal(1, received); Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint)); remoteEndPoint = receivedFrom as IPEndPoint; Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily); Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address); } }
private void AsyncBeginReceive() { UDPPacketBuffer buf; // FIXME: Disabled for now as this causes issues with reused packet objects interfering with each other // on Windows with m_asyncPacketHandling = true, though this has not been seen on Linux. // Possibly some unexpected issue with fetching UDP data concurrently with multiple threads. Requires more investigation. // if (UsePools) // buf = Pool.GetObject(); // else buf = new UDPPacketBuffer(); if (IsRunningInbound) { try { // kick off an async read m_udpSocket.BeginReceiveFrom( //wrappedBuffer.Instance.Data, buf.Data, 0, UDPPacketBuffer.BUFFER_SIZE, SocketFlags.None, ref buf.RemoteEndPoint, AsyncEndReceive, //wrappedBuffer); buf); } catch (SocketException e) { if (e.SocketErrorCode == SocketError.ConnectionReset) { m_log.Warn("[UDPBASE]: SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + m_udpPort); bool salvaged = false; while (!salvaged) { try { m_udpSocket.BeginReceiveFrom( //wrappedBuffer.Instance.Data, buf.Data, 0, UDPPacketBuffer.BUFFER_SIZE, SocketFlags.None, ref buf.RemoteEndPoint, AsyncEndReceive, //wrappedBuffer); buf); salvaged = true; } catch (SocketException) { } catch (ObjectDisposedException) { return; } } m_log.Warn("[UDPBASE]: Salvaged the UDP listener on port " + m_udpPort); } } catch (ObjectDisposedException e) { m_log.Error( string.Format("[UDPBASE]: Error processing UDP begin receive {0}. Exception ", UdpReceives), e); } catch (Exception e) { m_log.Error( string.Format("[UDPBASE]: Error processing UDP begin receive {0}. Exception ", UdpReceives), e); } } }
private static void BeginReceiveFrom() { icmpSocket.BeginReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, ref remoteEndPoint, ReceiveCallback, null); }
public void UdpReceiveData(IAsyncResult iar) { try { String sGPS; // Create temporary remote end Point IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0); EndPoint tempRemoteEP = (EndPoint)sender; // Get the Socket TCPSockets tcpSockets = (TCPSockets)iar.AsyncState; Socket remote = tcpSockets.socketUDP; // Call EndReceiveFrom to get the received Data int nBytesRec = remote.EndReceiveFrom(iar, ref tempRemoteEP); if (nBytesRec > 0) { sGPS = System.Text.Encoding.ASCII.GetString(tcpSockets.byTcpBuffer, 0, nBytesRec); try { if (m_GpsTracker.m_MessageMonitor != null) { m_GpsTracker.m_MessageMonitor.AddMessageTCPUDPRaw(sGPS); } } catch (Exception) { m_GpsTracker.m_MessageMonitor = null; } tcpSockets.sStream += sGPS; int iIndex = -1; char [] cEOL = { '\n', '\r' }; string sData = ""; do { iIndex = tcpSockets.sStream.IndexOfAny(cEOL); if (iIndex >= 0) { sData = tcpSockets.sStream.Substring(0, iIndex); sData = sData.Trim(cEOL); tcpSockets.sStream = tcpSockets.sStream.Remove(0, iIndex + 1); if (sData != "") { m_GpsTracker.ShowGPSIcon(sData.ToCharArray(), sData.Length, false, tcpSockets.iDeviceIndex, false, true, 0, 0); } } }while(iIndex >= 0); } GPSSource gpsSource = (GPSSource)m_GpsTracker.m_gpsSourceList[tcpSockets.iDeviceIndex]; EndPoint endPoint = new IPEndPoint(IPAddress.Any, Convert.ToInt32(gpsSource.iUDPPort)); remote.BeginReceiveFrom(tcpSockets.byTcpBuffer, 0, 1024, SocketFlags.None, ref endPoint, new AsyncCallback(UdpReceiveData), tcpSockets); } catch (Exception) { } }
// "The parameter remoteEP must not be of type DnsEndPoint." public void Socket_BeginReceiveFromDnsEndPoint_Throws() { using (Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp)) { int port = socket.BindToAnonymousPort(IPAddress.IPv6Loopback); EndPoint receivedFrom = new DnsEndPoint("localhost", port, AddressFamily.InterNetworkV6); Assert.Throws<ArgumentException>(() => { socket.BeginReceiveFrom(new byte[1], 0, 1, SocketFlags.None, ref receivedFrom, null, null); }); } }
private void Run() { var buf = new byte[65536]; var buf2 = new byte[65536]; try { MulticastSocket.BeginReceiveFrom(buf, 0, buf.Length, SocketFlags.None, ref MLEp, new AsyncCallback(ReceiveMulticast), buf); DiscoverDevices(); Thread.Sleep(1000); while (!Terminated) { try { DiscoverAction.Do(DiscoverDevices); GetExternalAddressAction.Do(delegate { if (GetExternalAddressAction.Frequency.ToSeconds < 1.0) { GetExternalAddressAction.Frequency = TickSpan.Seconds(60 * 30); GetExternalAddressAction.Start(); } if (WANIPConnectionsCtlInfo.Count > 0) { ControlInfo ci; lock ( WANIPConnectionsCtlInfo ) { ci = WANIPConnectionsCtlInfo.Values.First(); } RequestExternalIpAddress(ci); } }); ExternalPortMappingAction.Do(delegate { if (ExternalPortMappingAction.Frequency.ToSeconds < 1.0) { ExternalPortMappingAction.Frequency = TickSpan.Seconds(LeaseMapDurationSeconds - 200); ExternalPortMappingAction.Start(); } if (WANIPConnectionsCtlInfo.Count > 0) { UpdatePortMapping("TCP"); UpdatePortMapping("UDP"); } }); Thread.Sleep(1000); } catch (ThreadAbortException ex) { Logging.Log(ex); } catch (Exception ex) { Logging.Log(ex); } } } finally { Terminated = true; } }
public void BeginReceiveFrom_NotSupported() { using (Socket sock = new Socket(SocketType.Dgram, ProtocolType.Udp)) { EndPoint ep = new IPEndPoint(IPAddress.Any, 0); sock.Bind(ep); byte[] buf = new byte[1]; Assert.Throws<PlatformNotSupportedException>(() => sock.BeginReceiveFrom(buf, 0, buf.Length, SocketFlags.None, ref ep, null, null)); } }
/// <summary> /// Starts receiving data. /// </summary> /// <exception cref="ObjectDisposedException">Is raised when this calss is disposed and this method is accessed.</exception> public void Start() { if (m_IsDisposed) { throw new ObjectDisposedException(this.GetType().Name); } if (m_IsRunning) { return; } m_IsRunning = true; bool isIoCompletionSupported = Net_Utils.IsSocketAsyncSupported(); m_pEventArgs = new UDP_e_PacketReceived(); m_pBuffer = new byte[m_BufferSize]; if (isIoCompletionSupported) { m_pSocketArgs = new SocketAsyncEventArgs(); m_pSocketArgs.SetBuffer(m_pBuffer, 0, m_BufferSize); m_pSocketArgs.RemoteEndPoint = new IPEndPoint(m_pSocket.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, 0); m_pSocketArgs.Completed += delegate(object s1, SocketAsyncEventArgs e1){ if (m_IsDisposed) { return; } try{ if (m_pSocketArgs.SocketError == SocketError.Success) { OnPacketReceived(m_pBuffer, m_pSocketArgs.BytesTransferred, (IPEndPoint)m_pSocketArgs.RemoteEndPoint); } else { OnError(new Exception("Socket error '" + m_pSocketArgs.SocketError + "'.")); } IOCompletionReceive(); } catch (Exception x) { OnError(x); } }; } // Move processing to thread pool. ThreadPool.QueueUserWorkItem(delegate(object state){ if (m_IsDisposed) { return; } try{ if (isIoCompletionSupported) { IOCompletionReceive(); } else { EndPoint rtpRemoteEP = new IPEndPoint(m_pSocket.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, 0); m_pSocket.BeginReceiveFrom( m_pBuffer, 0, m_BufferSize, SocketFlags.None, ref rtpRemoteEP, new AsyncCallback(this.AsyncSocketReceive), null ); } } catch (Exception x) { OnError(x); } }); }