internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { if (!File.Exists(tcp4ConnectionsFile) || !File.Exists(tcp6ConnectionsFile)) { throw new PlatformNotSupportedException(SR.net_InformationUnavailableOnPlatform); } string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); // First line is header in each file. TcpConnectionInformation[] connections = new TcpConnectionInformation[v4connections.Length + v6connections.Length - 2]; int index = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { string line = v4connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { string line = v6connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } return connections; }
internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); TcpConnectionInformation[] connections = new TcpConnectionInformation[v4connections.Length + v6connections.Length - 2]; // First line is header in each file int index = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header { string line = v4connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header { string line = v6connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } return(connections); }
internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); TcpConnectionInformation[] connections = new TcpConnectionInformation[v4connections.Length + v6connections.Length - 2]; // First line is header in each file int index = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header { string line = v4connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header { string line = v6connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } return connections; }
private unsafe TcpConnectionInformation[] GetTcpConnections(bool listeners) { int realCount = Interop.Sys.GetEstimatedTcpConnectionCount(); int infoCount = realCount * 2; Interop.Sys.NativeTcpConnectionInformation *infos = stackalloc Interop.Sys.NativeTcpConnectionInformation[infoCount]; if (Interop.Sys.GetActiveTcpConnectionInfos(infos, &infoCount) == -1) { throw new NetworkInformationException(SR.net_PInvokeError); } TcpConnectionInformation[] connectionInformations = new TcpConnectionInformation[infoCount]; int nextResultIndex = 0; for (int i = 0; i < infoCount; i++) { Interop.Sys.NativeTcpConnectionInformation nativeInfo = infos[i]; TcpState state = nativeInfo.State; if (listeners != (state == TcpState.Listen)) { continue; } byte[] localBytes = new byte[nativeInfo.LocalEndPoint.NumAddressBytes]; fixed(byte *localBytesPtr = localBytes) { Buffer.MemoryCopy(nativeInfo.LocalEndPoint.AddressBytes, localBytesPtr, localBytes.Length, localBytes.Length); } IPAddress localIPAddress = new IPAddress(localBytes); IPEndPoint local = new IPEndPoint(localIPAddress, (int)nativeInfo.LocalEndPoint.Port); IPAddress remoteIPAddress; if (nativeInfo.RemoteEndPoint.NumAddressBytes == 0) { remoteIPAddress = IPAddress.Any; } else { byte[] remoteBytes = new byte[nativeInfo.RemoteEndPoint.NumAddressBytes]; fixed(byte *remoteBytesPtr = &remoteBytes[0]) { Buffer.MemoryCopy(nativeInfo.RemoteEndPoint.AddressBytes, remoteBytesPtr, remoteBytes.Length, remoteBytes.Length); } remoteIPAddress = new IPAddress(remoteBytes); } IPEndPoint remote = new IPEndPoint(remoteIPAddress, (int)nativeInfo.RemoteEndPoint.Port); connectionInformations[nextResultIndex++] = new SimpleTcpConnectionInformation(local, remote, state); } if (nextResultIndex != connectionInformations.Length) { Array.Resize(ref connectionInformations, nextResultIndex); } return(connectionInformations); }
internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { if (!File.Exists(tcp4ConnectionsFile) || !File.Exists(tcp6ConnectionsFile)) { throw new PlatformNotSupportedException(SR.net_InformationUnavailableOnPlatform); } string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); // First line is header in each file. TcpConnectionInformation[] connections = new TcpConnectionInformation[v4connections.Length + v6connections.Length - 2]; int index = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { string line = v4connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { string line = v6connections[i]; connections[index++] = ParseTcpConnectionInformationFromLine(line); } return(connections); }
public NetConnection(TcpConnectionInformation tcp) { Protocol = "TCP"; RemoteAddress = tcp.RemoteEndPoint.Address.ToString(); RemotePort = tcp.RemoteEndPoint.Port; LocalAddress = tcp.LocalEndPoint.Address.ToString(); LocalPort = tcp.LocalEndPoint.Port; State = tcp.State.ToString(); }
public static bool IsConnected(this System.Net.Sockets.TcpClient client) { System.Net.NetworkInformation.TcpConnectionInformation tcpConnectionInformation = System.Net.NetworkInformation.IPGlobalProperties.GetIPGlobalProperties() .GetActiveTcpConnections() .SingleOrDefault(x => x.RemoteEndPoint.Equals(client.Client.RemoteEndPoint)); return(tcpConnectionInformation == null ? false : tcpConnectionInformation.State == System.Net.NetworkInformation.TcpState.Established ? true : false); }
internal static IPEndPoint[] ParseActiveTcpListenersFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { if (!File.Exists(tcp4ConnectionsFile) || !File.Exists(tcp6ConnectionsFile)) { throw new PlatformNotSupportedException(SR.net_InformationUnavailableOnPlatform); } string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); // First line is header in each file. IPEndPoint[] endPoints = new IPEndPoint[v4connections.Length + v6connections.Length - 2]; int index = 0; int skip = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { TcpConnectionInformation ti = ParseTcpConnectionInformationFromLine(v4connections[i]); if (ti.State == TcpState.Listen) { endPoints[index] = ti.LocalEndPoint; index++; } else { skip++; } } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { TcpConnectionInformation ti = ParseTcpConnectionInformationFromLine(v6connections[i]); if (ti.State == TcpState.Listen) { endPoints[index] = ti.LocalEndPoint; index++; } else { skip++; } } if (skip != 0) { Array.Resize(ref endPoints, endPoints.Length - skip); } return(endPoints); }
private static bool IsPortAvailable(int port, TcpConnectionInformation[] tcpConnInfoArray) { bool isAvailable = true; foreach (TcpConnectionInformation tcpi in tcpConnInfoArray) { if (port > 0 && tcpi.LocalEndPoint.Port == port) { isAvailable = false; break; } } return isAvailable; }
public unsafe override TcpConnectionInformation[] GetActiveTcpConnections() { int realCount = Interop.Sys.GetEstimatedTcpConnectionCount(); int infoCount = (int)(realCount * 1.5f); Interop.Sys.NativeTcpConnectionInformation *infos = stackalloc Interop.Sys.NativeTcpConnectionInformation[infoCount]; while (Interop.Sys.GetActiveTcpConnectionInfos(infos, &infoCount) == -1) { var newAlloc = stackalloc Interop.Sys.NativeTcpConnectionInformation[infoCount]; infos = newAlloc; } TcpConnectionInformation[] connectionInformations = new TcpConnectionInformation[infoCount]; for (int i = 0; i < infoCount; i++) { Interop.Sys.NativeTcpConnectionInformation nativeInfo = infos[i]; TcpState state = nativeInfo.State; byte[] localBytes = new byte[nativeInfo.LocalEndPoint.NumAddressBytes]; fixed(byte *localBytesPtr = localBytes) { Buffer.MemoryCopy(nativeInfo.LocalEndPoint.AddressBytes, localBytesPtr, localBytes.Length, localBytes.Length); } IPAddress localIPAddress = new IPAddress(localBytes); IPEndPoint local = new IPEndPoint(localIPAddress, (int)nativeInfo.LocalEndPoint.Port); IPAddress remoteIPAddress; if (nativeInfo.RemoteEndPoint.NumAddressBytes == 0) { remoteIPAddress = IPAddress.Any; } else { byte[] remoteBytes = new byte[nativeInfo.RemoteEndPoint.NumAddressBytes]; fixed(byte *remoteBytesPtr = remoteBytes) { Buffer.MemoryCopy(nativeInfo.RemoteEndPoint.AddressBytes, remoteBytesPtr, remoteBytes.Length, remoteBytes.Length); } remoteIPAddress = new IPAddress(remoteBytes); } IPEndPoint remote = new IPEndPoint(remoteIPAddress, (int)nativeInfo.RemoteEndPoint.Port); connectionInformations[i] = new SimpleTcpConnectionInformation(local, remote, state); } return(connectionInformations); }
public override TcpConnectionInformation[] GetActiveTcpConnections() { List <string[]> list = new List <string[]>(); this.GetRows(this.TcpFile, list); this.GetRows(this.Tcp6File, list); TcpConnectionInformation[] array = new TcpConnectionInformation[list.Count]; for (int i = 0; i < array.Length; i++) { IPEndPoint local = this.ToEndpoint(list[i][1]); IPEndPoint remote = this.ToEndpoint(list[i][2]); TcpState state = (TcpState)int.Parse(list[i][3], NumberStyles.HexNumber); array[i] = new TcpConnectionInformationImpl(local, remote, state); } return(array); }
private string GetLocalEndPoint(System.Net.Sockets.Socket s) { System.Net.NetworkInformation.IPGlobalProperties iPGlobalProperties = System.Net.NetworkInformation.IPGlobalProperties.GetIPGlobalProperties(); System.Net.NetworkInformation.TcpConnectionInformation[] activeTcpConnections = iPGlobalProperties.GetActiveTcpConnections(); System.Net.IPEndPoint iPEndPoint = (System.Net.IPEndPoint)s.RemoteEndPoint; System.Net.NetworkInformation.TcpConnectionInformation[] array = activeTcpConnections; for (int i = 0; i < array.Length; i++) { System.Net.NetworkInformation.TcpConnectionInformation tcpConnectionInformation = array[i]; if (iPEndPoint.ToString() == tcpConnectionInformation.RemoteEndPoint.ToString()) { return(new System.Net.IPEndPoint(tcpConnectionInformation.LocalEndPoint.Address, ((System.Net.IPEndPoint)s.LocalEndPoint).Port).ToString()); } } return("127.0.0.1:0"); }
public unsafe override TcpConnectionInformation[] GetActiveTcpConnections() { int realCount = Interop.Sys.GetEstimatedTcpConnectionCount(); int infoCount = realCount * 2; Interop.Sys.NativeTcpConnectionInformation* infos = stackalloc Interop.Sys.NativeTcpConnectionInformation[infoCount]; while (Interop.Sys.GetActiveTcpConnectionInfos(infos, &infoCount) == -1) { Interop.Sys.NativeTcpConnectionInformation* newAlloc = stackalloc Interop.Sys.NativeTcpConnectionInformation[infoCount]; infos = newAlloc; } TcpConnectionInformation[] connectionInformations = new TcpConnectionInformation[infoCount]; for (int i = 0; i < infoCount; i++) { Interop.Sys.NativeTcpConnectionInformation nativeInfo = infos[i]; TcpState state = nativeInfo.State; byte[] localBytes = new byte[nativeInfo.LocalEndPoint.NumAddressBytes]; fixed (byte* localBytesPtr = localBytes) { Buffer.MemoryCopy(nativeInfo.LocalEndPoint.AddressBytes, localBytesPtr, localBytes.Length, localBytes.Length); } IPAddress localIPAddress = new IPAddress(localBytes); IPEndPoint local = new IPEndPoint(localIPAddress, (int)nativeInfo.LocalEndPoint.Port); IPAddress remoteIPAddress; if (nativeInfo.RemoteEndPoint.NumAddressBytes == 0) { remoteIPAddress = IPAddress.Any; } else { byte[] remoteBytes = new byte[nativeInfo.RemoteEndPoint.NumAddressBytes]; fixed (byte* remoteBytesPtr = remoteBytes) { Buffer.MemoryCopy(nativeInfo.RemoteEndPoint.AddressBytes, remoteBytesPtr, remoteBytes.Length, remoteBytes.Length); } remoteIPAddress = new IPAddress(remoteBytes); } IPEndPoint remote = new IPEndPoint(remoteIPAddress, (int)nativeInfo.RemoteEndPoint.Port); connectionInformations[i] = new SimpleTcpConnectionInformation(local, remote, state); } return connectionInformations; }
private unsafe TcpConnectionInformation[] GetTcpConnections(bool listeners) { int realCount = Interop.Sys.GetEstimatedTcpConnectionCount(); int infoCount = realCount * 2; Interop.Sys.NativeTcpConnectionInformation[] infos = new Interop.Sys.NativeTcpConnectionInformation[infoCount]; fixed(Interop.Sys.NativeTcpConnectionInformation *infosPtr = infos) { if (Interop.Sys.GetActiveTcpConnectionInfos(infosPtr, &infoCount) == -1) { throw new NetworkInformationException(SR.net_PInvokeError); } } TcpConnectionInformation[] connectionInformations = new TcpConnectionInformation[infoCount]; int nextResultIndex = 0; for (int i = 0; i < infoCount; i++) { Interop.Sys.NativeTcpConnectionInformation nativeInfo = infos[i]; TcpState state = nativeInfo.State; if (listeners != (state == TcpState.Listen)) { continue; } IPAddress localIPAddress = new IPAddress(new ReadOnlySpan <byte>(nativeInfo.LocalEndPoint.AddressBytes, checked ((int)nativeInfo.LocalEndPoint.NumAddressBytes))); IPEndPoint local = new IPEndPoint(localIPAddress, (int)nativeInfo.LocalEndPoint.Port); IPAddress remoteIPAddress = nativeInfo.RemoteEndPoint.NumAddressBytes == 0 ? IPAddress.Any : new IPAddress(new ReadOnlySpan <byte>(nativeInfo.RemoteEndPoint.AddressBytes, checked ((int)nativeInfo.RemoteEndPoint.NumAddressBytes))); IPEndPoint remote = new IPEndPoint(remoteIPAddress, (int)nativeInfo.RemoteEndPoint.Port); connectionInformations[nextResultIndex++] = new SimpleTcpConnectionInformation(local, remote, state); } if (nextResultIndex != connectionInformations.Length) { Array.Resize(ref connectionInformations, nextResultIndex); } return(connectionInformations); }
public override TcpConnectionInformation [] GetActiveTcpConnections() { List <string []> list = new List <string []> (); GetRows(TcpFile, list); GetRows(Tcp6File, list); TcpConnectionInformation [] ret = new TcpConnectionInformation [list.Count]; for (int i = 0; i < ret.Length; i++) { // sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode IPEndPoint local = ToEndpoint(list [i] [1]); IPEndPoint remote = ToEndpoint(list [i] [2]); TcpState state = (TcpState)int.Parse(list [i] [3], NumberStyles.HexNumber); ret [i] = new TcpConnectionInformationImpl(local, remote, state); } return(ret); }
public override TcpConnectionInformation[] GetActiveTcpConnections() { List <Win32IPGlobalProperties.Win32_MIB_TCPROW> list = null; List <Win32IPGlobalProperties.Win32_MIB_TCP6ROW> list2 = null; this.FillTcpTable(out list, out list2); int count = list.Count; TcpConnectionInformation[] array = new TcpConnectionInformation[count + list2.Count]; for (int i = 0; i < count; i++) { array[i] = list[i].TcpInfo; } for (int j = 0; j < list2.Count; j++) { array[count + j] = list2[j].TcpInfo; } return(array); }
public override TcpConnectionInformation [] GetActiveTcpConnections() { List <Win32_MIB_TCPROW> tab4 = null; List <Win32_MIB_TCP6ROW> tab6 = null; FillTcpTable(out tab4, out tab6); int size4 = tab4.Count; TcpConnectionInformation [] ret = new TcpConnectionInformation [size4 + tab6.Count]; for (int i = 0; i < size4; i++) { ret [i] = tab4 [i].TcpInfo; } for (int i = 0; i < tab6.Count; i++) { ret [size4 + i] = tab6 [i].TcpInfo; } return(ret); }
public override TcpConnectionInformation[] GetActiveTcpConnections() { List <Win32_MIB_TCPROW> tab = null; List <Win32_MIB_TCP6ROW> tab2 = null; FillTcpTable(out tab, out tab2); int count = tab.Count; TcpConnectionInformation[] array = new TcpConnectionInformation[count + tab2.Count]; for (int i = 0; i < count; i++) { array[i] = tab[i].TcpInfo; } for (int j = 0; j < tab2.Count; j++) { array[count + j] = tab2[j].TcpInfo; } return(array); }
internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string?tcp4ConnectionsFile, string?tcp6ConnectionsFile) { string[] v4connections; string[] v6connections; if (tcp4ConnectionsFile != null) { string tcp4FileContents = ReadAllText(tcp4ConnectionsFile); v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); } else { v4connections = Array.Empty <string>(); } if (tcp6ConnectionsFile != null) { string tcp6FileContents = ReadAllText(tcp6ConnectionsFile); v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); } else { v6connections = Array.Empty <string>(); } // First line is header in each file. On WSL, this file may be empty. int count = 0; if (v4connections.Length > 0) { count += v4connections.Length - 1; } if (v6connections.Length > 0) { count += v6connections.Length - 1; } // First line is header in each file. TcpConnectionInformation[] connections = new TcpConnectionInformation[count]; int index = 0; int skip = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { string line = v4connections[i]; connections[index] = ParseTcpConnectionInformationFromLine(line); if (connections[index].State == TcpState.Listen) { skip++; } else { index++; } } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { string line = v6connections[i]; connections[index] = ParseTcpConnectionInformationFromLine(line); if (connections[index].State == TcpState.Listen) { skip++; } else { index++; } } if (skip != 0) { Array.Resize(ref connections, connections.Length - skip); } return(connections); }
public override TcpConnectionInformation [] GetActiveTcpConnections () { List<Win32_MIB_TCPROW> tab4 = null; List<Win32_MIB_TCP6ROW> tab6 = null; FillTcpTable (out tab4, out tab6); int size4 = tab4.Count; TcpConnectionInformation [] ret = new TcpConnectionInformation [size4 + tab6.Count]; for (int i = 0; i < size4; i++) ret [i] = tab4 [i].TcpInfo; for (int i = 0; i < tab6.Count; i++) ret [size4 + i] = tab6 [i].TcpInfo; return ret; }
public override TcpConnectionInformation [] GetActiveTcpConnections () { List<string []> list = new List<string []> (); GetRows (TcpFile, list); GetRows (Tcp6File, list); TcpConnectionInformation [] ret = new TcpConnectionInformation [list.Count]; for (int i = 0; i < ret.Length; i++) { // sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode IPEndPoint local = ToEndpoint (list [i] [1]); IPEndPoint remote = ToEndpoint (list [i] [2]); TcpState state = (TcpState) int.Parse (list [i] [3], NumberStyles.HexNumber); ret [i] = new TcpConnectionInformationImpl (local, remote, state); } return ret; }
internal static TcpConnectionInformation[] ParseActiveTcpConnectionsFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { if (!File.Exists(tcp4ConnectionsFile) || !File.Exists(tcp6ConnectionsFile)) { throw new PlatformNotSupportedException(SR.net_InformationUnavailableOnPlatform); } string tcp4FileContents = File.ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = File.ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); // First line is header in each file. On WSL, this file may be empty. int count = 0; if (v4connections.Length > 0) { count += v4connections.Length - 1; } if (v6connections.Length > 0) { count += v6connections.Length - 1; } // First line is header in each file. TcpConnectionInformation[] connections = new TcpConnectionInformation[count]; int index = 0; int skip = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { string line = v4connections[i]; connections[index] = ParseTcpConnectionInformationFromLine(line); if (connections[index].State == TcpState.Listen) { skip++; } else { index++; } } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { string line = v6connections[i]; connections[index] = ParseTcpConnectionInformationFromLine(line); if (connections[index].State == TcpState.Listen) { skip++; } else { index++; } } if (skip != 0) { Array.Resize(ref connections, connections.Length - skip); } return(connections); }
internal static IPEndPoint[] ParseActiveTcpListenersFromFiles(string tcp4ConnectionsFile, string tcp6ConnectionsFile) { string tcp4FileContents = ReadAllText(tcp4ConnectionsFile); string[] v4connections = tcp4FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); string tcp6FileContents = ReadAllText(tcp6ConnectionsFile); string[] v6connections = tcp6FileContents.Split(s_newLineSeparator, StringSplitOptions.RemoveEmptyEntries); // First line is header in each file. On WSL, this file may be empty. int count = 0; if (v4connections.Length > 0) { count += v4connections.Length - 1; } if (v6connections.Length > 0) { count += v6connections.Length - 1; } // First line is header in each file. IPEndPoint[] endPoints = new IPEndPoint[count]; int index = 0; int skip = 0; // TCP Connections for (int i = 1; i < v4connections.Length; i++) // Skip first line header. { TcpConnectionInformation ti = ParseTcpConnectionInformationFromLine(v4connections[i]); if (ti.State == TcpState.Listen) { endPoints[index] = ti.LocalEndPoint; index++; } else { skip++; } } // TCP6 Connections for (int i = 1; i < v6connections.Length; i++) // Skip first line header. { TcpConnectionInformation ti = ParseTcpConnectionInformationFromLine(v6connections[i]); if (ti.State == TcpState.Listen) { endPoints[index] = ti.LocalEndPoint; index++; } else { skip++; } } if (skip != 0) { Array.Resize(ref endPoints, endPoints.Length - skip); } return(endPoints); }
public bool PlayerInList(TcpConnectionInformation info) { foreach (AccessListEntry e in accessList) { if (e.Matches(info.RemoteEndPoint.Address)) { return true; } } return false; }