protected static bool IsConnected(Socket socket) { if (socket == null) return false; try { if (!socket.Poll(1, SelectMode.SelectRead) || socket.Available != 0) return true; socket.Close(); return false; } catch { socket.Close(); return false; } }
private void StartListening() { Socket serverSocket = null; EndPoint endPoint = new IPEndPoint(IPAddress.Any, port); try { serverSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); serverSocket.Blocking = true; serverSocket.Bind(endPoint); serverSocket.Listen(queueSize); log.Info("server started, listening on port " + port); running = true; stopped = false; while (running) { // Calling socket.Accept blocks the thread until the next incoming connection, // making difficult to stop the server from another thread. // The Poll always returns after the specified delay elapsed, or immeidately // returns if it detects an incoming connection. It's the perfect method // to make this loop regularly che the running var, ending gracefully // if requested. if (serverSocket.Poll(SocketPollMicroseconds, SelectMode.SelectRead)) { Socket clientSocket = serverSocket.Accept(); log.Info("new request received"); ConversionRequest connection = new ConversionRequest(clientSocket, converter); Thread clientThread = new Thread(new ThreadStart(connection.Run)); clientThread.Start(); } } } catch (Exception e) { log.Error("exception", e); } finally { if (serverSocket != null) serverSocket.Close(); running = false; stopped = true; log.Info("server stopped"); } }
private void StartListening() { Socket serverSocket = null; EndPoint endPoint = new IPEndPoint(IPAddress.Any, port); try { serverSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); serverSocket.Blocking = true; serverSocket.Bind(endPoint); serverSocket.Listen(queueSize); log.Info("server started, listening on port " + port); running = true; stopped = false; while (running) { // Calling socket.Accept blocks the thread until the next incoming connection, // making difficult to stop the server from another thread. // The Poll always returns after the specified delay elapsed, or immediately // returns if it detects an incoming connection. It's the perfect method // to make this loop regularly check the running var, ending gracefully // if requested. if (serverSocket.Poll(SocketPollMicroseconds, SelectMode.SelectRead)) { Socket clientSocket = serverSocket.Accept(); Interlocked.Increment(ref connectionsCounter.value); ConversionRequest connection = new ConversionRequest(clientSocket, converter, connectionsCounter); // Creating a single thread for every connection has huge costs, // so I leverage the .NET internal thread pool ThreadPool.QueueUserWorkItem(connection.Run); } } } catch (Exception e) { log.Error("exception", e); } finally { if (serverSocket != null) serverSocket.Close(); running = false; stopped = true; log.Info("server stopped ("+ connectionsCounter.value + " connections still open)"); } }
/// <summary> /// Send the response data to the client. /// </summary> private void Sender() { // If in async mode. if (_context != null && _context.IsAsyncMode) { // Poll the socket when data can be sent. if (_socket != null && _socket.Connected) { // If read to sent. bool polled = false; try { // Send until empty. while (_responseStream != null && _responseStream.Length > 0) { // If read to sent. polled = _socket.Poll(10, SelectMode.SelectWrite); // If read to send. if (polled) { // Send the data. SocketSend(SendData()); } } } catch { } } } }
// // // public int ReceiveBytes() { Array.Clear(_receiveBuffer, 0, _receiveBuffer.Length); if (_socket == null) { throw new SocketException("Socket is null."); } _socket.Poll(-1, SNS.SelectMode.SelectRead); // wait until we can read // read the 4 byte header that tells us how many bytes we will get byte[] readHeader = new byte[4]; _socket.Receive(readHeader, 0, 4, SNS.SocketFlags.None); int bytesToRead = BitConverter.ToInt32(readHeader, 0); //Helper.WriteLine( "+++bytesToRead==" + bytesToRead ) ; // read the bytes in a loop int readBlockSize = (int)_socket.GetSocketOption(SNS.SocketOptionLevel.Socket, SNS.SocketOptionName.ReceiveBuffer); //Helper.WriteLine( "+++readBlockSize==" + readBlockSize ) ; int bytesReadSoFar = 0; while (true) { int bytesLeftToRead = bytesToRead - bytesReadSoFar; if (bytesLeftToRead <= 0) { break; // finished receiving } _socket.Poll(-1, SNS.SelectMode.SelectRead); // wait until we can read // do the read int bytesToReadThisTime = Math.Min(readBlockSize, bytesLeftToRead); if (bytesToReadThisTime + bytesReadSoFar > SocketConstants.SOCKET_MAX_TRANSFER_BYTES) { throw new SocketException("You are trying to read " + bytesToRead + " bytes. Dont read more than " + SocketConstants.SOCKET_MAX_TRANSFER_BYTES + " bytes."); } int bytesReadThisTime = _socket.Receive(_receiveBuffer, bytesReadSoFar, bytesToReadThisTime, SNS.SocketFlags.None); //Helper.WriteLine( "+++bytesReadThisTime==" + bytesReadThisTime ) ; bytesReadSoFar += bytesReadThisTime; } _statsBytesReceived += bytesReadSoFar; // update stats //Helper.WriteLine( "+++finished reading" ) ; return(bytesReadSoFar); }
private static FoundServerInformation BroadcastPing(IPAddress broadcastAddress, int port) { using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp) { SendTimeout = OptionLanSocketTimeout, ReceiveTimeout = OptionLanSocketTimeout, Blocking = false }) { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); var buffer = new byte[3]; try { socket.SendTo(BitConverter.GetBytes(200), SocketFlags.DontRoute, new IPEndPoint(broadcastAddress, port)); if (socket.Poll(OptionLanPollTimeout * 1000, SelectMode.SelectRead)) { socket.ReceiveFrom(buffer, ref remoteEndPoint); } } catch (SocketException) { return null; } if (buffer[0] != 200 || buffer[1] + buffer[2] <= 0) { return null; } var foundServer = remoteEndPoint as IPEndPoint; if (foundServer == null) { return null; } return new FoundServerInformation { Ip = foundServer.Address.ToString(), Port = BitConverter.ToInt16(buffer, 1) }; } }
public virtual BrowserResponse ExecuteRequest(string url, string method) { Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); sock.Connect(new IPEndPoint(FastCgiServer, FastCgiServerPort)); // Our request ushort requestId = 1; Request = new WebServerSocketRequest(sock, requestId); Request.SendBeginRequest(Role.Responder, true); SendParams(new Uri(url), method); Request.SendEmptyStdin(); // Receive the data from the other side if (!sock.Poll(MaxPollTime, SelectMode.SelectRead)) throw new Exception("Data took too long"); byte[] buf = new byte[4096]; int bytesRead; bool endRequest = false; while ((bytesRead = sock.Receive(buf)) > 0) { endRequest = Request.FeedBytes(buf, 0, bytesRead).Any(x => x.RecordType == RecordType.FCGIEndRequest); } if (!endRequest) throw new Exception("EndRequest was not received."); return new BrowserResponse(Request.AppStatus, Request.Stdout); }
/// <summary> /// This code is used to connect to a TCP socket with timeout option. /// </summary> /// <param name="endPoint">IP endpoint of remote server</param> /// <param name="timeoutMs">Timeout to wait until connect</param> /// <returns>Socket object connected to server</returns> public static Socket ConnectToServerWithTimeout(EndPoint endPoint, int timeoutMs) { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { socket.Blocking = false; socket.Connect(endPoint); socket.Blocking = true; return socket; } catch (SocketException socketException) { if (socketException.ErrorCode != 10035) { socket.Close(); throw; } if (!socket.Poll(timeoutMs * 1000, SelectMode.SelectWrite)) { socket.Close(); throw new NGRIDException("The host failed to connect. Timeout occured."); } socket.Blocking = true; return socket; } }
static void Start() { var socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //var ip = new IPAddress(new byte[] { 192, 168, 1, 87 }); var endPoint = new IPEndPoint(IPAddress.Any, MAPLE_SERVER_BROADCASTPORT); socket.Connect(endPoint); //byte[] bytesToSend = Encoding.UTF8.GetBytes(msg); while (true) { //socket.SendTo(bytesToSend, bytesToSend.Length, SocketFlags.None, endPoint); while (socket.Poll(2000000, SelectMode.SelectRead)) { if (socket.Available > 0) { byte[] inBuf = new byte[socket.Available]; EndPoint recEndPoint = new IPEndPoint(IPAddress.Any, 0); socket.ReceiveFrom(inBuf, ref recEndPoint); //if (!recEndPoint.Equals(endPoint))// Check if the received packet is from the 192.168.0.2 // continue; Debug.WriteLine(new String(Encoding.UTF8.GetChars(inBuf))); } } Thread.Sleep(100); } }
/// <summary> /// Try to update both system and RTC time using the NTP protocol /// </summary> /// <param name="TimeServer">Time server to use, ex: pool.ntp.org</param> /// <param name="GmtOffset">GMT offset in minutes, ex: -240</param> /// <returns>Returns true if successful</returns> public DateTime NTPTime(string TimeServer, int GmtOffset = 0) { Socket s = null; DateTime resultTime = DateTime.Now; try { EndPoint rep = new IPEndPoint(Dns.GetHostEntry(TimeServer).AddressList[0], 123); s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); byte[] ntpData = new byte[48]; Array.Clear(ntpData, 0, 48); ntpData[0] = 0x1B; // Set protocol version s.SendTo(ntpData, rep); // Send Request if (s.Poll(30 * 1000 * 1000, SelectMode.SelectRead)) // Waiting an answer for 30s, if nothing: timeout { s.ReceiveFrom(ntpData, ref rep); // Receive Time byte offsetTransmitTime = 40; ulong intpart = 0; ulong fractpart = 0; for (int i = 0; i <= 3; i++) intpart = (intpart << 8) | ntpData[offsetTransmitTime + i]; for (int i = 4; i <= 7; i++) fractpart = (fractpart << 8) | ntpData[offsetTransmitTime + i]; ulong milliseconds = (intpart * 1000 + (fractpart * 1000) / 0x100000000L); s.Close(); resultTime = new DateTime(1900, 1, 1) + TimeSpan.FromTicks((long)milliseconds * TimeSpan.TicksPerMillisecond); Utility.SetLocalTime(resultTime.AddMinutes(GmtOffset)); } s.Close(); } catch { try { s.Close(); } catch { } } return resultTime; }
public void ProcessRequest(Socket socket) { using (socket) { var requestHandler = _requestHandlerFactory.Create(socket); if (socket.Poll(5000000, SelectMode.SelectRead)) { try { requestHandler.ProcessRequest(); } catch (Exception e) // Catch all unhandled internal server exceptions { if (_serverContext.ExceptionHandler != null) { _serverContext.ExceptionHandler.HandleException(e); } else { Debug.Print("Unhandled exception in web server, Message: " + e.Message + ", StackTrace: " + e.StackTrace); } } } } }
/// <summary> /// Processes the request. /// </summary> private void ProcessRequest() { const Int32 c_microsecondsPerSecond = 1000000; // 'using' ensures that the client's socket gets closed. using (m_clientSocket) { // Wait for the client request to start to arrive. Byte[] buffer = new Byte[1024]; if (m_clientSocket.Poll(5 * c_microsecondsPerSecond, SelectMode.SelectRead)) { // If 0 bytes in buffer, then the connection has been closed, // reset, or terminated. if (m_clientSocket.Available == 0) { return; } // Read the first chunk of the request (we don't actually do // anything with it). Int32 bytesRead = m_clientSocket.Receive(buffer, m_clientSocket.Available, SocketFlags.None); // Return a static HTML document to the client. String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><head><title>.NET Micro Framework Web Server</title></head>" + "<body><bold><a href=\"http://www.microsoft.com/netmf/\">Learn more about the .NET Micro Framework by clicking here</a></bold></body></html>"; m_clientSocket.Send(Encoding.UTF8.GetBytes(s)); } } }
private void worker() { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, ipPort); EndPoint remoteEndPoint = (EndPoint)ipEndPoint; socket.Bind(ipEndPoint); socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse(ipAddress))); byte[] receivedData = new byte[1024]; while (_KeepWorking) { if (socket.Poll(200000, SelectMode.SelectRead)) { socket.Receive(receivedData); switch (apiVersionStr) { case "0.8": apiVersionInt = 8; parser_v08(receivedData); break; case "1.0+": parser_v10p(receivedData); break; } receivedData = new byte[1024]; } } socket.Close(); }
/// <summary> /// Reads an IcmpPacket from the wire using the specified socket from the specified end point /// </summary> /// <param name="socket">The socket to read</param> /// <param name="packet">The packet read</param> /// <param name="ep">The end point read from</param> /// <returns></returns> public virtual bool Read(Socket socket, EndPoint ep, int timeout, out IcmpPacket packet, out int bytesReceived) { const int MAX_PATH = 256; packet = null; bytesReceived = 0; /* * check the parameters * */ if (socket == null) throw new ArgumentNullException("socket"); if (socket == null) throw new ArgumentNullException("ep"); // see if any data is readable on the socket bool success = socket.Poll(timeout * 1000, SelectMode.SelectRead); // if there is data waiting to be read if (success) { // prepare to receive data byte[] bytes = new byte[MAX_PATH]; bytesReceived = socket.ReceiveFrom(bytes, bytes.Length, SocketFlags.None, ref ep); /* * convert the bytes to an icmp packet * */ // packet = IcmpPacket.FromBytes(bytes); } return success; }
public static void Run() { //Debug.Print(StringUtil.Format("APP started {0}.", DateTime.Now)); NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces(); foreach (var networkInterface in allNetworkInterfaces) { if (networkInterface.NetworkInterfaceType == NetworkInterfaceType.Ethernet) { //networkInterface.PhysicalAddress = new byte[] { 0x00, 0xFF, 0xC3, 0x1E, 0x77, 0x01 }; //networkInterface.EnableStaticIP("192.168.0.44", "255.255.255.0", "192.168.0.1"); networkInterface.EnableDhcp(); Thread.Sleep(2000); Debug.Print(networkInterface.NetworkInterfaceType.ToString()); Debug.Print(networkInterface.IPAddress); } } Debug.Print("Network interface configured."); // Debug.Print(StringUtil.Format("IP {0}, NM {1}, GW {2}.", eth.IPAddress, eth.SubnetMask, eth.GatewayAddress)); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //IPEndPoint relayEndpoint = new IPEndPoint(IPAddress.Parse("78.46.63.147"), 9090); IPEndPoint relayEndpoint = new IPEndPoint(IPAddress.Parse("192.168.0.1"), 80); try { socket.Connect(relayEndpoint); } catch (Exception ex) { //Debug.Print(StringUtil.Format("Connect error {0}. ST {1}.", ex.Message, ex.StackTrace)); Debug.Print(ex.Message); } while (true) { try { if (socket.Poll(100, SelectMode.SelectRead)) { Debug.Print("Socket connected."); } } catch (Exception ex) { Debug.Print("Socket not connected."); } Thread.Sleep(500); } }
private static bool SocketConnected(Socket s) { bool part1 = s.Poll(1000, SelectMode.SelectRead); bool part2 = (s.Available == 0); if (part1 & part2) return false; else return true; }
public void Connect() { const Int32 c_microsecondsPerSecond = 1000000; try { Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); string request = string.Empty; int timeout = (query.IndexOf("init") > 0) ? pool + 3 : pool - 1; if (Program.TEST) request = "POST /receivertest/receiver.aspx HTTP/1.1\n"; else request = "POST /ReceiverNew/Receiver HTTP/1.1\n"; request += "Host: " + common.dname + " \n"; request += "Content-Type: application/x-www-form-urlencoded\n"; // request += "Connection: close\r\n"; request += "Content-Length: " + this.query.Length + "\r\n\r\n"; request += this.query; sock.Bind(sock.LocalEndPoint); sock.Connect(this.endPoint); Byte[] bytesToSend = Encoding.UTF8.GetBytes(request); sock.Send(bytesToSend, bytesToSend.Length, 0); Byte[] buffer = new Byte[1024]; String reply = String.Empty; while (sock.Poll(timeout * c_microsecondsPerSecond, SelectMode.SelectRead)) { if (sock.Available == 0) break; Array.Clear(buffer, 0, buffer.Length); Int32 bytesRead = sock.Receive(buffer); reply += new String(Encoding.UTF8.GetChars(buffer)); } if (reply != string.Empty) { string header = reply.Substring(0, reply.IndexOf("\r\n\r\n")); string response = reply.Substring(reply.IndexOf("\r\n\r\n")).Trim(); // malina ConnectionSuccess(this, new NetSuccessEventArgs() { NetStatus = netStatus.Success, Header = header, Answers = response }); } else { ConnectionSuccess(this, new NetSuccessEventArgs() { NetStatus = netStatus.Failure, Answers = string.Empty }); } sock.Close(); } catch (SocketException se) { DebugPrint(" Connection socket aborted. " + se.ToString()); ConnectionSuccess(this, new NetSuccessEventArgs() { NetStatus = netStatus.Failure, Answers = string.Empty }); } catch (Exception e) { DebugPrint("Connect: Connection died. " + e.ToString()); ConnectionSuccess(this, new NetSuccessEventArgs() { NetStatus = netStatus.Failure, Answers = string.Empty }); } }
public static bool IsConnected(this Sockets.Socket Socket) { try { return(!(Socket.Poll(1, Sockets.SelectMode.SelectRead) && Socket.Available == 0)); } catch (Sockets.SocketException) { return(false); } }
public void Initialize(Main p) { Popup pop = new Popup(); Byte[] buff = new byte[128]; _out = new Queue<string>(); _in = new Queue<string>(); t = new Treatment(); t.Initialize(p); pop.ShowDialog(); if (pop.isValid()) { try { IPAddress[] IPs = Dns.GetHostAddresses(pop.GetIp()); s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); s.Connect(IPs[0], pop.GetPort()); } catch (SocketException e) { Console.WriteLine("Error on Socket\nWhat: {0}", e.Message); MessageBox.Show(e.Message, "Connection failure", MessageBoxButtons.OK, MessageBoxIcon.Error); Application.Exit(); connected = false; return; } catch (FormatException e) { MessageBox.Show(e.Message, "Invalid port.", MessageBoxButtons.OK, MessageBoxIcon.Error); Application.Exit(); connected = false; return; } if (s.Poll(60000000, SelectMode.SelectRead)) { connected = true; s.Receive(buff); } else { MessageBox.Show("Connection impossible with the server.", "Connection timeout.", MessageBoxButtons.OK, MessageBoxIcon.Error); connected = true; return; } if (Encoding.UTF8.GetString(buff).CompareTo("BIENVENUE\n") == 0) { s.Send(Encoding.UTF8.GetBytes("GRAPHIC\n")); } } else { connected = false; } }
private bool SocketConnected(Socket s) { if (!s.Connected) return false; bool part1 = s.Poll(10000, SelectMode.SelectError); bool part2 = (s.Available == 0); if (part1 && part2) return false; else return true; }
bool SocketConnected(Socket s) { bool part1 = s.Poll(0, SelectMode.SelectRead); bool part2 = (s.Available == 0); if (part1 & part2) {//connection is closed return false; } return true; }
/// <summary> /// checks if a socket has data available /// </summary> /// <param name="socket">Socket</param> /// <returns><b>true</b> if data is available; <b>false</b> otherwise</returns> internal static bool IsDataAvailable(this System.Net.Sockets.Socket socket) { try { if (socket != null && !socket.Poll(0, SelectMode.SelectRead) && !socket.Poll(0, SelectMode.SelectError)) { byte[] buffer = new byte[1]; if (socket.Receive(buffer, SocketFlags.Peek) != 0) { return(true); } } } catch { /* IGNORE */ } return(false); }
/// <summary> /// Issues a request for the root document on the specified server. /// </summary> /// <param name="Proxy"></param> /// <param name="URL"></param> /// <param name="port"></param> /// <returns></returns> private static String GetWebPage(String Proxy, String URL, Int32 port) { const Int32 c_microsecondsPerSecond = 1000000; string host = GetHostFromURL(URL); string server = Proxy.Length > 0 ? Proxy : host; // Create a socket connection to the specified server and port. using (Socket serverSocket = ConnectSocket(server, port)) { // Send request to the server. String request = "GET " + URL + " HTTP/1.1\r\nHost: " + host + "\r\nConnection: Close\r\n\r\n"; Byte[] bytesToSend = Encoding.UTF8.GetBytes(request); serverSocket.Send(bytesToSend, bytesToSend.Length, 0); // Reusable buffer for receiving chunks of the document. Byte[] buffer = new Byte[1024]; // Accumulates the received page as it is built from the buffer. String page = String.Empty; // Wait up to 30 seconds for initial data to be available. Throws // an exception if the connection is closed with no data sent. DateTime timeoutAt = DateTime.Now.AddSeconds(30); while (serverSocket.Available == 0 && DateTime.Now < timeoutAt) { System.Threading.Thread.Sleep(100); } // Poll for data until 30-second timeout. Returns true for data and // connection closed. while (serverSocket.Poll(30 * c_microsecondsPerSecond, SelectMode.SelectRead)) { // If there are 0 bytes in the buffer, then the connection is // closed, or we have timed out. if (serverSocket.Available == 0) { break; } // Zero all bytes in the re-usable buffer. Array.Clear(buffer, 0, buffer.Length); // Read a buffer-sized HTML chunk. Int32 bytesRead = serverSocket.Receive(buffer); // Append the chunk to the string. page = page + new String(Encoding.UTF8.GetChars(buffer)); } // Return the complete string. return(page); } }
public static bool IsConnected(Socket socket) { try { return !(socket.Poll(1, SelectMode.SelectRead) && socket.Available == 0); } catch (SocketException) { return false; } }
/// <summary> /// checks if a socket is connected /// </summary> /// <param name="socket">Socket</param> /// <returns><b>true</b> if connected; <b>false</b> otherwise</returns> internal static bool IsConnected(this System.Net.Sockets.Socket socket) { try { if (socket != null && !socket.Poll(0, SelectMode.SelectRead) && socket.Available == 0) { return(false); } } catch { } return(false); }
public void Start() { if (serverSocket == null) { serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint localEP = new IPEndPoint(IPAddress.Any, port); serverSocket.Bind(localEP); serverSocket.Listen(int.MaxValue); isStopped = false; new Thread(delegate { using (serverSocket) { while (!isStopped) { try { if (serverSocket.Poll(1000 * 10, SelectMode.SelectRead)) { TcpSession session = new TcpSession(serverSocket.Accept()); session.DataReceived += new TcpSessionDataReceivedEventHandler(NetworkClient_DataReceived); session.Disconnected += new TcpSessionEventHandler(NetworkClient_Disconnected); sessions.Add(session); if (SessionConnected != null) SessionConnected(session); session.Start(); } } catch (SocketException e) { if (e.ErrorCode != 10035) break; } catch (Exception e) { Debug.Print(e.Message); break; } Thread.Sleep(0); } } serverSocket.Close(); serverSocket = null; sessions.Clear(); }).Start(); } }
public static bool CanWrite(Socket socket) { if (socket.Connected) { #if FEATURE_SOCKET_POLL return socket.Poll(-1, SelectMode.SelectWrite); #else return true; #endif // FEATURE_SOCKET_POLL } return false; }
/// <summary> /// 是否连接了 /// </summary> /// <param name="socket"></param> /// <returns></returns> public static bool IsSocketConnected(this System.Net.Sockets.Socket socket) { bool part1 = socket.Poll(1000, SelectMode.SelectRead); bool part2 = (socket.Available == 0); if (part1 && part2) { return(false); } else { return(true); } }
public static bool CanRead(Socket socket) { if (socket.Connected) { #if FEATURE_SOCKET_POLL return socket.Poll(-1, SelectMode.SelectRead) && socket.Available > 0; #else return true; #endif // FEATURE_SOCKET_POLL } return false; }
bool SocketConnected(System.Net.Sockets.Socket s) { bool part1 = s.Poll(1000, SelectMode.SelectRead); bool part2 = (s.Available == 0); if (part1 && part2) { return(false); } else { return(true); } }
public static void Main() { uint watchdogTimer = 1000; PWM umbrella = new PWM(Pins.GPIO_PIN_D10); //Right controller Socket receiveSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); receiveSocket.Bind(new IPEndPoint(IPAddress.Any, 4444)); byte[] rxData = new byte[10]; // Incoming data buffer double raw_speed = 0; while (true) /* Main program loop */ { /* Try to receive new data - spend 100uS waiting */ if (receiveSocket.Poll(100, SelectMode.SelectRead)) { int rxCount = receiveSocket.Receive(rxData); watchdogTimer = 0; } if (watchdogTimer < 200) // Only enable the robot if data was received recently { // 900 (full rev) to 2100 (full fwd), 1500 is neutral raw_speed += (rxData[0] - 127.5) * .001; // Add the value of the stick to the current speed // Mediate added speed to negative if it's below center line(on ipgamepad). Make the added speed very little because the mount of UDP packets is large. // map function only accept input between 0-255 if (raw_speed < 0) { raw_speed = 0; } else if (raw_speed > 255) { raw_speed = 255; } // Stick maintains speed unless calibrate changes. umbrella.SetPulse(20000, map((uint)raw_speed, 0, 255, 1500, 2100)); // Right controller 1500-2100 -- only positive watchdogTimer++; } else { // Disable the robot umbrella.SetDutyCycle(0); } } }
private void ProcessRequest() { const int c_microsecondsPerSecond = 1000000; using (clientSocket) { while (true) { try { if (clientSocket.Poll(5 * c_microsecondsPerSecond, SelectMode.SelectRead)) { // If the butter is zero-lenght, the connection has been closed or terminated. if (clientSocket.Available == 0) { break; } byte[] buffer = new byte[clientSocket.Available]; int bytesRead = clientSocket.Receive(buffer, clientSocket.Available, SocketFlags.None); byte[] data = new byte[bytesRead]; buffer.CopyTo(data, 0); DataReceivedEventArgs args = new DataReceivedEventArgs(clientSocket.LocalEndPoint, clientSocket.RemoteEndPoint, data); socket.OnDataReceived(args); if (args.ResponseData != null) { clientSocket.Send(args.ResponseData); } if (args.Close) { break; } } } catch (Exception) { break; } } } }
public static void Main() { using (Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, port); serverSocket.Bind(remoteEndPoint); if (serverSocket.Poll(-1, //timeout in micro seconds SelectMode.SelectRead)) { byte[] inBuffer = new byte[serverSocket.Available]; int count = serverSocket.ReceiveFrom(inBuffer, ref remoteEndPoint); string message = new string(Encoding.UTF8.GetChars(inBuffer)); Debug.Print("Received '" + message + "'."); } } }
/// <summary> /// polls socket if endpoint is available /// <seealso cref="System.Net.Sockets.Socket"/> /// </summary> /// <param name="s">socket to check</param> /// <returns></returns> private bool IsSocketConnected(System.Net.Sockets.Socket s) { if (s == null) { return(false); } bool poll = s.Poll(1000, System.Net.Sockets.SelectMode.SelectRead); bool avail = (s.Available == 0); if (poll && avail) { return(false); } else { return(true); } }
//check connection public static bool CheckConnection(Socket socket) { if (socket == null) return false; try { //if the socket says connected we test it to check if its true or not //if it says not connected then its clearly not connected if (socket.Connected) { //poll the connection. the poll will return true if : // - a connection is pending // - data is available for reading // - connection is closed or unavailable // // so if it returns false, the connection is there but nothing can be read // if its true, we need to check if we can read data. if we can't, its either pending (useless) or closed (even more useless) // so we mark it as closed. bool bpoll = false; bpoll = socket.Poll(0, SelectMode.SelectRead); if (bpoll) { byte[] buff = new byte[1]; int recv_value = socket.Receive(buff, SocketFlags.Peek); if (recv_value <= 0) { // Client disconnected return false; } } } else return false; } catch { //something went wrong. im guessing connection is closed but meh. lets just assume connection is a no go return false; } return true; }
// Methods ============================================================================ public override void Start(IPEndPoint ep) { // Verify IPEndPoints IPEndPoint[] globalEPs = IPGlobalProperties.GetIPGlobalProperties().GetActiveUdpListeners(); foreach (IPEndPoint globalEP in globalEPs) { if (ep.Equals(globalEP)) throw new ApplicationException(ep.ToString() + " is in listening."); } System.Threading.Thread thread = new System.Threading.Thread(() => { server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); server.Bind(ep); /// ** Report ListenerStarted event if (ListenStarted != null) ListenStarted(this, new ListenEventArgs(ep)); EndPoint epClient = new IPEndPoint(IPAddress.Any, 0); isExitThread = false; while (true) { if (server.Poll(500000, SelectMode.SelectRead)) { int bytesRead = server.ReceiveFrom(readbuffer, readbuffer.Length, SocketFlags.None, ref epClient); /// ** Report ClientReadMsg event if (ClientRecvPack != null) ClientRecvPack(this, new ClientEventArgs(ep, epClient, readbuffer.Take(bytesRead).ToArray())); } else if (isExitThread == true) { isExitThread = false; break; } } server.Close(); /// ** Report ListenerStopped event if (ListenStopped != null) ListenStopped(this, new ListenEventArgs(ep)); }); thread.IsBackground = true; thread.Start(); }
public static bool IsSocketConnected_Poll(System.Net.Sockets.Socket socket) { #region remarks /* As zendar wrote, it is nice to use the Socket.Poll and Socket.Available, but you need to take into conside ration * that the socket might not have been initialized in the first place. * This is the last (I believe) piece of information and it is supplied by the Socket.Connected property. * The revised version of the method would looks something like this: * from:http://stackoverflow.com/questions/2661764/how-to-check-if-a-socket-is-connected-disconnected-in-c */ #endregion #region 过程 if (socket == null) { return(false); } return(!((socket.Poll(1000, SelectMode.SelectRead) && (socket.Available == 0)) || !socket.Connected)); #endregion }
internal void SendInternalServerError(Socket socket, System.Exception e) { var response = "Internal server error\r\n\r\nException\r\nMessage:\r\n" + e.Message + "\r\nStack Trace:\r\n" + e.StackTrace; var length = response.Length; string innerException = string.Empty; if (e.InnerException != null) { innerException = "\r\nInner Exception: \r\nMessage: " + e.InnerException.Message + "\r\nStack Trace: " + e.InnerException.StackTrace; length += innerException.Length; } var header = "HTTP/1.1 500 Internal Server Error\r\nContent-Length: " + length + "\r\nConnection: close\r\n\r\n"; if (socket.Poll(5000000, SelectMode.SelectWrite)) { socket.Send(Encoding.UTF8.GetBytes(header), header.Length, SocketFlags.None); socket.Send(Encoding.UTF8.GetBytes(response), response.Length, SocketFlags.None); if (innerException != string.Empty) { socket.Send(Encoding.UTF8.GetBytes(innerException), innerException.Length, SocketFlags.None); } } }
//* Runs as a background task to reconnect if connection is lost private void TestConnection(object cancelToken) { System.Threading.CancellationToken token = (System.Threading.CancellationToken)cancelToken; while (!token.IsCancellationRequested) { //Console.WriteLine("Top of While") if (AutoConnect) { if (WorkSocket != null) { if ((WorkSocket.Poll(2000, SelectMode.SelectRead)) && (WorkSocket.Available == 0)) { try { CloseConnection(); Connect(); } catch (Exception ex) { } //Console.WriteLine(Now & "Open again") } } else { try { Connect(); } catch (Exception ex) { } } } token.WaitHandle.WaitOne(3000); //Threading.Thread.SpinWait(2000) } }
private Socket tryGetSocket() { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // socket.Blocking = false; byte[] byteAddress = new byte[] { 127, 0, 0, 1 }; IPAddress ipAddress = new IPAddress(byteAddress); try { socket.Connect(ipAddress, port); } catch (SocketException socketException) { if (socketException.ErrorCode == 10035) { // WSAEWOULDBLOCK bool socketGood = socket.Poll(10000000, SelectMode.SelectWrite); if (!socketGood) return null; } } return socket; }
public static bool TestSocketConnection(IPEndPoint endPoint, int port, int timeoutMs) { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { // do not block - do not want to be forced to wait on (too- long) timeout socket.Blocking = false; // initiate connection - will cause exception because we're not blocking socket.Connect(endPoint); return false; } catch (SocketException socketException) { // check if this exception is for the expected 'Would Block' error if (socketException.ErrorCode != 10035) { socket.Close(); // the error is not 'Would Block', so propogate the exception return false; } // if we get here, the error is 'Would Block' so just continue execution } // wait until connected or we timeout int timeoutMicroseconds = timeoutMs * 1000; if (socket.Poll(timeoutMicroseconds, SelectMode.SelectRead) == false) { // timed out socket.Close(); return false; } // *** AT THIS POINT socket.Connected SHOULD EQUAL TRUE BUT IS FALSE! ARGH! // set socket back to blocking socket.Blocking = true; socket.Close(); return true; } }
/// <summary> /// This function checks polls a socket to see if it's connected /// </summary> /// <param name="target">The Socket to check</param> /// <returns>True if connected; otherwise, false</returns> private bool IsSocketConnected(System.Net.Sockets.Socket target) { if (!target.Connected) { return(false); } try { bool bstate = target.Poll(1, System.Net.Sockets.SelectMode.SelectRead); if (bstate & (target.Available == 0)) { return(false); } return(true); } catch (Exception ex) { Console.WriteLine(ex.ToString()); return(false); } }
/// <summary> /// Initializes a new instance of the <see cref="RestClient"/> class /// </summary> /// <param name="host"> /// The REST API host name /// </param> /// <param name="port"> /// The port on which to connect to the REST API /// </param> public RestClient(string host, int port) { Host = host; var hostEntry = Dns.GetHostEntry(host); foreach (var address in hostEntry.AddressList) { if (address == null) { continue; } var ipEndPoint = new IPEndPoint(address, port); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { socket.Connect(ipEndPoint); var isConnected = socket.Poll(10, SelectMode.SelectWrite); if (isConnected) { IpEndPoint = ipEndPoint; break; } } catch (Exception e) { #if DEBUG Console.WriteLine("Error connecting to host: " + e.Message); #endif } finally { socket.Close(); } } }
/// <summary> /// Determine whether data is ready to be read /// </summary> public static bool IsDataAvailable(this System.Net.Sockets.Socket s) { return(s.Poll(1000, SelectMode.SelectRead) && (s.Available > 0)); }
bool Utils.Wrappers.Interfaces.ISocket.Poll(int microSeconds, System.Net.Sockets.SelectMode mode) { return(InternalSocket.Poll(microSeconds, mode)); }
public void Disposed7 () { Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); s.Close(); s.Poll (100, 0); }
private bool Readable(int aTimeout) { return(mSocket.Poll(aTimeout, SelectMode.SelectRead)); }
/// <summary> /// /// </summary> /// <param name="c"></param> /// <returns></returns> public static bool IsOnline(System.Net.Sockets.Socket c) { return(!((c.Poll(1000, System.Net.Sockets.SelectMode.SelectRead) && (c.Available == 0)) || !c.Connected)); }
public static bool IsSocketConnected(System.Net.Sockets.Socket s) { return(!((s.Poll(1000, SelectMode.SelectRead) && (s.Available == 0)) || !s.Connected)); }
private byte[] QueryServer(byte[] query,string serverIP) { byte[] retVal = null; try { IPEndPoint ipRemoteEndPoint = new IPEndPoint(IPAddress.Parse(serverIP),53); Socket udpClient = new Socket(AddressFamily.InterNetwork,SocketType.Dgram,ProtocolType.Udp); IPEndPoint ipLocalEndPoint = new IPEndPoint(IPAddress.Any, 0); EndPoint localEndPoint = (EndPoint)ipLocalEndPoint; udpClient.Bind(localEndPoint); udpClient.Connect(ipRemoteEndPoint); //send query udpClient.Send(query); // Wait until we have a reply if(udpClient.Poll(5*1000000,SelectMode.SelectRead)){ retVal = new byte[512]; udpClient.Receive(retVal); } udpClient.Close(); } catch { } return retVal; }
// // // public void Listen(SNS.AddressFamily addressFamily, int port, int timeoutSec, string stopFile, Dictionary <string, string> parameters) { DateTime startTime = System.DateTime.Now; SNS.Socket listenSocket = null; try { // delete stop file File.Delete(stopFile); // create the main listening socket listenSocket = new SNS.Socket(addressFamily, SNS.SocketType.Stream, SNS.ProtocolType.Tcp); // set socket options listenSocket.SetSocketOption(SNS.SocketOptionLevel.Socket, SNS.SocketOptionName.ReuseAddress, 1); listenSocket.SetSocketOption(SNS.SocketOptionLevel.Socket, SNS.SocketOptionName.Linger, new SNS.LingerOption(false, 0)); listenSocket.SetSocketOption(SNS.SocketOptionLevel.Tcp, SNS.SocketOptionName.NoDelay, 1); // bind the listening socket if (addressFamily == SNS.AddressFamily.InterNetworkV6) { listenSocket.Bind(new IPEndPoint(IPAddress.IPv6Any, port)); } else if (addressFamily == SNS.AddressFamily.InterNetwork) { listenSocket.Bind(new IPEndPoint(IPAddress.Any, port)); } else { throw new SocketException("Cant bind server socket. Unknown address family " + addressFamily.ToString()); } // listen listenSocket.Listen(SocketConstants.SOCKET_BACKLOG); Console.WriteLine("SocketServer - listening on port [{0}] family [{1}]", port, addressFamily.ToString()); // accept client connections - run in a thread pool thread using (MyThreadPoolManager tpm = new MyThreadPoolManager(50, 5000)) // max 50 concurrent clients { while (true) { // see if it is time to stop the server if (File.Exists(stopFile)) // stop listening if stop file exists { _stop = true; } else if (timeoutSec > 0) // stop listening if server timed out { TimeSpan ts = System.DateTime.Now.Subtract(startTime); if (ts.TotalSeconds >= timeoutSec) { _stop = true; } } if (_stop) // time to go { tpm.Shutdown(); Console.WriteLine("SocketServer - listening on port [{0}] stopping...", port); break; } if (listenSocket.Poll(200000, SNS.SelectMode.SelectRead)) // ready to accept - 0.2 sec wait max { SNS.Socket clientSocket = listenSocket.Accept(); T tpi = new T(); tpi.Parameters = parameters; tpi.SetRawSocket(clientSocket); tpm.Queue(tpi); } } //tpm.WaitUntilAllStarted() ; // servers alive until all queued sockets execute } } finally // tidy up { Console.WriteLine("SocketServer [{0}] - listening on port [{1}] stopped", addressFamily, port); try { listenSocket.Shutdown(SNS.SocketShutdown.Both); } catch (Exception) {} try { listenSocket.Close(); } catch (Exception) {} } } // end method