public static int GetNextAvailablePortTcp(int start, int end) { IPGlobalProperties iPGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); HashSet <int> hashSet = new HashSet <int>(); IPEndPoint[] activeTcpListeners = iPGlobalProperties.GetActiveTcpListeners(); for (int i = 0; i < activeTcpListeners.Length; i++) { IPEndPoint iPEndPoint = activeTcpListeners[i]; hashSet.Add(iPEndPoint.Port); } TcpConnectionInformation[] activeTcpConnections = iPGlobalProperties.GetActiveTcpConnections(); for (int j = 0; j < activeTcpConnections.Length; j++) { TcpConnectionInformation tcpConnectionInformation = activeTcpConnections[j]; hashSet.Add(tcpConnectionInformation.LocalEndPoint.Port); } for (int k = start; k <= end; k++) { if (!hashSet.Contains(k)) { return(k); } } return(-1); }
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); }
private void printTCP(TcpConnectionInformation conn) { Console.Write(conn.LocalEndPoint.Address.ToString() + ":" + conn.LocalEndPoint.Port.ToString()); Console.Write(" | "); Console.Write(conn.RemoteEndPoint.Address.ToString() + ":" + conn.RemoteEndPoint.Port.ToString()); Console.WriteLine(); }
public static TcpState GetState(this TcpClient tcpClient) { if (tcpClient.Client.LocalEndPoint == null) { return(TcpState.Unknown); } try { var endPoint = (IPEndPoint)tcpClient.Client.LocalEndPoint; IPAddress ipv4 = endPoint.Address; if (ipv4.IsIPv4MappedToIPv6) { ipv4 = ipv4.MapToIPv4(); } TcpConnectionInformation foo = IPGlobalProperties.GetIPGlobalProperties() .GetActiveTcpConnections() .SingleOrDefault(x => x.LocalEndPoint.Address.Equals(ipv4) && x.LocalEndPoint.Port == endPoint.Port); return(foo != null ? foo.State : TcpState.Unknown); } catch (ObjectDisposedException e) { return(TcpState.Closed); } }
internal TcpState GetTcpState() { TcpConnectionInformation conInfo = IPGlobalProperties.GetIPGlobalProperties() .GetActiveTcpConnections() .SingleOrDefault(con => con.LocalEndPoint.Equals(this.Client.Client.LocalEndPoint)); return(conInfo?.State ?? TcpState.Unknown); }
public ConnectionItem(TcpConnectionInformation information) { Startpoint = information.LocalEndPoint.ToString(); Endpoint = information.RemoteEndPoint.ToString(); getDescription(information); State = information.State; DisplayName = FilterString = string.Concat(Startpoint, " - ", Endpoint); }
public static void newConnection(TcpConnectionInformation conn) { IPRecord ipR = new IPRecord(); ipR.RemoteEndPoint = conn.RemoteEndPoint.ToString(); GetInfo(ipR); ipList.Add(ipR); }
private TcpState GetState() { // Check our Tcp's state. TcpConnectionInformation info = IPGlobalProperties.GetIPGlobalProperties() .GetActiveTcpConnections() .SingleOrDefault(x => x.LocalEndPoint.Equals(this.tcp.Client.LocalEndPoint)); return((info != null) ? info.State : TcpState.Unknown); }
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(); }
static private void Worker() { //TcpListener server = new TcpListener(IPAddress.Parse("127.0.0.1"), 59049); TcpListener server = new TcpListener(IPAddress.Any, 59049); try { server.Start(); while (true) { // Wait until New Connection while (!server.Pending()) { Thread.Sleep(2000); } // Clean up lock (ResponseQueue) ResponseQueue.Clear(); using (TcpClient connection = server.AcceptTcpClient()) using (NetworkStream networkStream = new NetworkStream(connection.Client)) { //Congestion Control connection.ReceiveBufferSize = 256; //Split a Seperate Thread for Reading WorkerReadingStart(networkStream); //Split a Seperate Thread for Writing WorkerWritingStart(networkStream); //Wait until Disconnected or New Connection TcpState state; do { Thread.Sleep(5000); TcpConnectionInformation tcpinfo = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().SingleOrDefault(x => (x.LocalEndPoint.Equals(connection.Client.LocalEndPoint) & x.RemoteEndPoint.Equals(connection.Client.RemoteEndPoint))); state = tcpinfo != null ? tcpinfo.State : TcpState.Unknown; } while (!server.Pending() && state != TcpState.Closed && state != TcpState.CloseWait && state != TcpState.Closing); //Disconnect WorkerWritingStop(); WorkerReadingStop(); networkStream.Close(); connection.Close(); } } } catch (Exception) //Including Thread Abort { WorkerWritingStop(); WorkerReadingStop(); server.Stop(); } }
private static TcpState GetState(TcpClient tcpClient) { TcpConnectionInformation foo = IPGlobalProperties.GetIPGlobalProperties() .GetActiveTcpConnections() .SingleOrDefault(x => x.LocalEndPoint.Equals(tcpClient.Client.LocalEndPoint) && x.RemoteEndPoint.Equals(tcpClient.Client.RemoteEndPoint) ); return(foo != null ? foo.State : TcpState.Unknown); }
public static SortedList GetOpenTCPPorts() { SortedList OpenTCPPorts = new SortedList(); IPGlobalProperties properties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] TCPconnections = properties.GetActiveTcpConnections(); TcpConnectionInformation tcpConnectionInfo = default(TcpConnectionInformation); foreach (TcpConnectionInformation tempLoopVar_tcpConnectionInfo in TCPconnections) { tcpConnectionInfo = tempLoopVar_tcpConnectionInfo; if (!OpenTCPPorts.ContainsKey(tcpConnectionInfo.LocalEndPoint.Port)) { OpenTCPPorts.Add(tcpConnectionInfo.LocalEndPoint.Port, tcpConnectionInfo.LocalEndPoint.Port); } string localIP = tcpConnectionInfo.LocalEndPoint.Address.ToString(); string remoteIP = tcpConnectionInfo.RemoteEndPoint.Address.ToString(); if (localIP == remoteIP) { if (!OpenTCPPorts.ContainsKey(tcpConnectionInfo.RemoteEndPoint.Port)) { OpenTCPPorts.Add(tcpConnectionInfo.RemoteEndPoint.Port, tcpConnectionInfo.RemoteEndPoint.Port); } } } System.Net.IPEndPoint[] endPoints = null; endPoints = properties.GetActiveTcpListeners(); foreach (var IPEndPoint in endPoints) { if (!OpenTCPPorts.ContainsKey(IPEndPoint.Port)) { OpenTCPPorts.Add(IPEndPoint.Port, IPEndPoint.Port); } } endPoints = properties.GetActiveUdpListeners(); foreach (var IPEndPoint in endPoints) { if (!OpenTCPPorts.ContainsKey(IPEndPoint.Port)) { OpenTCPPorts.Add(IPEndPoint.Port, IPEndPoint.Port); } } return(OpenTCPPorts); }
public bool PlayerInList(TcpConnectionInformation info) { foreach (AccessListEntry e in accessList) { if (e.Matches(info.RemoteEndPoint.Address)) { return(true); } } return(false); }
public Connection(TcpConnectionInformation info) { this.RemoteAddress = info.RemoteEndPoint.Address; this.LocalAddress = info.LocalEndPoint.Address; this.LocalPort = info.LocalEndPoint.Port; this.RemotePort = info.RemoteEndPoint.Port; this.State = info.State; double?a, b; GeoDatabase.GetPosition(RemoteAddress.ToString(), out a, out b); this.Longitude = a; this.Latitude = b; }
private async void getDescription(TcpConnectionInformation information) { try { var entry = await Dns.GetHostEntryAsync(information.RemoteEndPoint.Address.ToString()); Description = entry.HostName; DisplayName = FilterString = string.Concat(Startpoint, " - ", Endpoint, "(", Description, ")"); } catch { Description = ""; } }
//List used tcp port static void ListAvailableTCPPort(ref ArrayList usedPort) { IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator myEnum = tcpConnInfoArray.GetEnumerator(); while (myEnum.MoveNext()) { TcpConnectionInformation TCPInfo = (TcpConnectionInformation)myEnum.Current; Console.WriteLine("Port {0} {1} {2} ", TCPInfo.LocalEndPoint, TCPInfo.RemoteEndPoint, TCPInfo.State); usedPort.Add(TCPInfo.LocalEndPoint.Port); } }
public static void ListNotAllowedPort(ref List <ExceptionPort> usedPort) { IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator myEnum = tcpConnInfoArray.GetEnumerator(); while (myEnum.MoveNext()) { TcpConnectionInformation TCPInfo = (TcpConnectionInformation)myEnum.Current; Console.WriteLine("Port {0} {1} {2} ", TCPInfo.LocalEndPoint, TCPInfo.RemoteEndPoint, TCPInfo.State); usedPort.Add(new ExceptionPort { Port = TCPInfo.LocalEndPoint.Port }); } }
/// <summary> /// Returns the TcpConnectionInformation for a remote endpoint, or null if one /// could not be found. /// </summary> /// <param name="localEndPoint"></param> /// <param name="remoteEndPoint"></param> /// <returns></returns> private TcpConnectionInformation GetRemoteConnection(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint) { TcpConnectionInformation result = null; if (_TcpConnections != null && _TcpConnections.Length > 0) { var localEndPointText = localEndPoint.ToString(); var remoteEndPointText = remoteEndPoint.ToString(); result = _TcpConnections.FirstOrDefault(r => r.RemoteEndPoint != null && r.LocalEndPoint != null && r.RemoteEndPoint.ToString() == remoteEndPointText && r.LocalEndPoint.ToString() == localEndPointText ); } return(result); }
/// <summary> /// Gets the TCP endpoints list on localhost. /// </summary> /// <returns></returns> public static List <IPEndPoint> GetTcpEndpoints() { var tcpEndpoints = new List <IPEndPoint>(); IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator myEnum = tcpConnInfoArray.GetEnumerator(); while (myEnum.MoveNext()) { TcpConnectionInformation tcpInfo = (TcpConnectionInformation)myEnum.Current; tcpEndpoints.Add(new IPEndPoint(IPAddress.Loopback, tcpInfo.LocalEndPoint.Port)); } return(tcpEndpoints); }
protected int RemotePortInUseCount(int port) { int num = 0; IPGlobalProperties iPGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] activeTcpConnections = iPGlobalProperties.GetActiveTcpConnections(); TcpConnectionInformation[] array = activeTcpConnections; for (int i = 0; i < array.Length; i++) { TcpConnectionInformation tcpConnectionInformation = array[i]; if (tcpConnectionInformation.get_RemoteEndPoint().get_Port() == port) { num++; } } return(num); }
//function to check if the port sent is in use //returns false if the port is in use or else return true private bool PortAvailable(int port) { IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections(); System.Collections.IEnumerator myEnum = tcpConnInfoArray.GetEnumerator(); while (myEnum.MoveNext()) { TcpConnectionInformation tcpi = (TcpConnectionInformation)myEnum.Current; if (tcpi.LocalEndPoint.Port == port) { return(false); } } return(true); }
public static bool IsPortAvailableTcp(int port) { IPGlobalProperties iPGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); HashSet <int> hashSet = new HashSet <int>(); IPEndPoint[] activeTcpListeners = iPGlobalProperties.GetActiveTcpListeners(); for (int i = 0; i < activeTcpListeners.Length; i++) { IPEndPoint iPEndPoint = activeTcpListeners[i]; hashSet.Add(iPEndPoint.Port); } TcpConnectionInformation[] activeTcpConnections = iPGlobalProperties.GetActiveTcpConnections(); for (int j = 0; j < activeTcpConnections.Length; j++) { TcpConnectionInformation tcpConnectionInformation = activeTcpConnections[j]; hashSet.Add(tcpConnectionInformation.LocalEndPoint.Port); } return(hashSet.Contains(port)); }
public Boolean checkConnection() { // 연결 상태 체크 TcpClient형의 객체명 : client IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnections = new TcpConnectionInformation[1]; Boolean return_value = false; try { tcpConnections = ipProperties.GetActiveTcpConnections().Where(x => x.LocalEndPoint.Equals(client.LocalEndPoint) && x.RemoteEndPoint.Equals(client.RemoteEndPoint)).ToArray(); } catch { // Exception 처리 -> 여기서는 Disconnected된 것으로 보면 된다. return_value = false; } if (tcpConnections != null && tcpConnections.Length > 0) { TcpState stateOfConnection = tcpConnections.First().State; if (stateOfConnection == TcpState.Established) { //Connected ~~ return_value = true; } else { //Disconnected ~~ return_value = false; } } if (return_value == true && client.Connected == false) { return_value = false; } return(return_value); }
public TcpState GetState(TcpClient tcpClient) { //var foo = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().SingleOrDefault(x => x.LocalEndPoint.Equals(tcpClient.Client.LocalEndPoint)); //return foo != null ? foo.State : TcpState.Unknown; try { TcpConnectionInformation tcpConnectionInformation = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().SingleOrDefault(x => x.LocalEndPoint.Equals(tcpClient.Client.LocalEndPoint) && x.RemoteEndPoint.Equals(tcpClient.Client.RemoteEndPoint)); return(tcpConnectionInformation != null ? tcpConnectionInformation.State : TcpState.Unknown); //TcpConnectionInformation[] tcpConnectionInformation = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().(x => x.LocalEndPoint.Equals(tcpClient.Client.LocalEndPoint) && x.RemoteEndPoint.Equals(tcpClient.Client.RemoteEndPoint)).ToArray(); // //if (tcpConnectionInformation != null && tcpConnectionInformation.Length > 0) //{ // TcpState tcpState = tcpConnectionInformation.First().State; // // return tcpState; //} //else // return TcpState.Unknown; } catch (InvalidOperationException Ie) { //share.EventLog(string.Format("{0} (0) > {1}", MethodBase.GetCurrentMethod().Name, Ie.Message), false); share.EventLog(null, string.Empty, string.Format("\t{0} (0) > {1}", MethodBase.GetCurrentMethod().Name, Ie.Message), false); return(TcpState.Unknown); } catch (Exception ex) { //share.EventLog(string.Format("{0} (1) > {1}", MethodBase.GetCurrentMethod().Name, ex.Message), false); share.EventLog(null, string.Empty, string.Format("\t{0} (1) > {1}", MethodBase.GetCurrentMethod().Name, ex.Message), false); return(TcpState.Unknown); } }
public void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) { string con; if (e.ProgressPercentage == 1) { button1.Enabled = true; } if (checkBox1.Checked == true) { try { transfer tr = (transfer)e.UserState; con = tr.SourceDns + " " + tr.DestDns + " " + tr.state + "\r\n"; textBox1.Text = textBox1.Text + con; } catch { textBox1.Text = " "; } } else { try { TcpConnectionInformation tcp = (TcpConnectionInformation)e.UserState; con = tcp.LocalEndPoint + " : " + " " + tcp.RemoteEndPoint + " " + tcp.State + "\r\n"; textBox1.Text = textBox1.Text + con; } catch { textBox1.Text = " "; } } }
private static int[] GetPortFree() { //int port = 0; List <int> ls_port_ok = new List <int>() { }; for (int k = 3000; k < 65000; k++) { ls_port_ok.Add(k); } List <int> ls_port = new List <int>() { }; IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator myEnum = tcpConnInfoArray.GetEnumerator(); while (myEnum.MoveNext()) { TcpConnectionInformation TCPInfo = (TcpConnectionInformation)myEnum.Current; //Console.WriteLine("Port {0} {1} {2} ", TCPInfo.LocalEndPoint, TCPInfo.RemoteEndPoint, TCPInfo.State); ls_port.Add(TCPInfo.LocalEndPoint.Port); } ls_port = ls_port.OrderBy(x => x).ToList(); ls_port_ok = ls_port_ok.Where(p => !ls_port.Any(x => x == p)).ToList(); //if (ls_port_ok.Count > 0) port = ls_port_ok[0]; return(ls_port_ok.ToArray()); }
private static void ValidateInfo(TcpConnectionInformation tcpConnectionInformation, IPEndPoint localEP, IPEndPoint remoteEP, TcpState state) { Assert.Equal(localEP, tcpConnectionInformation.LocalEndPoint); Assert.Equal(remoteEP, tcpConnectionInformation.RemoteEndPoint); Assert.Equal(state, tcpConnectionInformation.State); }
public void Enforce() { if (AccessList.Count > 0) { IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] connectionInformation = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator enumerator = connectionInformation.GetEnumerator(); Logging.OnLogMessage(String.Format("Enforcing {0}", Mode), MessageType.Info); while (enumerator.MoveNext()) { TcpConnectionInformation info = (TcpConnectionInformation)enumerator.Current; if (info.LocalEndPoint.Port == Settings.Instance.Port && info.State == TcpState.Established) { int ret = 0; bool actionTaken = false; bool playerFound = PlayerInList(info); switch (Mode) { case AccessMode.Whitelist: if (!playerFound) { ret = Helper.DisconnectWrapper.CloseRemoteIP(info.RemoteEndPoint.Address.ToString(), info.RemoteEndPoint.Port); actionTaken = true; } break; case AccessMode.Blacklist: if (playerFound) { ret = Helper.DisconnectWrapper.CloseRemoteIP(info.RemoteEndPoint.Address.ToString(), info.RemoteEndPoint.Port); actionTaken = true; } break; } if (actionTaken) { switch (ret) { case 0: Logging.OnLogMessage(String.Format("The user {0} has been kicked", info.RemoteEndPoint.Address.ToString()), MessageType.Info); break; case 317: Logging.OnLogMessage(String.Format("Could not kick user {0}: Access denied", info.RemoteEndPoint.Address.ToString()), MessageType.Warning); break; case 0x5: Logging.OnLogMessage(String.Format("Could not kick user {0}. You might lack the the required privileges.", info.RemoteEndPoint.Address.ToString()), MessageType.Warning); break; case 0x57: Logging.OnLogMessage("Internal error: wrong parameter", MessageType.Error); break; case 0x32: Logging.OnLogMessage("IPv4 Transport is not configured properly", MessageType.Error); break; default: Logging.OnLogMessage(String.Format("Disconnecting returned with {0}", ret), MessageType.Info); break; } } } } } }
/// <summary> /// Updates the current players /// </summary> /// <returns></returns> public void UpdatePlayers() { IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] connectionInformation = ipGlobalProperties.GetActiveTcpConnections(); IEnumerator enumerator = connectionInformation.GetEnumerator(); int count = 0; ObservableCollection <Helper.PlayerInfo> current = new ObservableCollection <Helper.PlayerInfo>(); ObservableCollection <Helper.PlayerInfo> all = new ObservableCollection <Helper.PlayerInfo>(Players); while (enumerator.MoveNext()) { TcpConnectionInformation info = (TcpConnectionInformation)enumerator.Current; if (info.LocalEndPoint.Port == 12345 && info.State == TcpState.Established) { count++; if (!all.Contains(info.RemoteEndPoint.Address)) { all.Add(info.RemoteEndPoint.Address); } current.Add(info.RemoteEndPoint.Address); } } #if DEBUG //Time for some debug data Random rnd = new Random(); int playersToGenerate = rnd.Next(1, 10); for (int i = 0; i < playersToGenerate; i++) { int a = rnd.Next(0, 255); IPAddress tmp; string ip = "127.0.0." + a.ToString(); if (IPAddress.TryParse(ip, out tmp)) { if (!current.Contains(tmp)) { current.Add(tmp); } if (!all.Contains(tmp)) { all.Add(tmp); } } } current.Add(IPAddress.Parse("192.168.178.1")); #endif ConnectedPlayers = current; Players = all; }
public static SortedList GetOpenTCPPortsInARangeOfPorts(int lowPortNumber, int uppperPortNumber) { int lowerLimit = 0; int upperLimit = 0; if (lowPortNumber <= uppperPortNumber) { lowerLimit = lowPortNumber; upperLimit = uppperPortNumber; } else { lowerLimit = uppperPortNumber; upperLimit = lowPortNumber; } SortedList OpenTCPPorts = new SortedList(); IPGlobalProperties properties = IPGlobalProperties.GetIPGlobalProperties(); TcpConnectionInformation[] TCPconnections = properties.GetActiveTcpConnections(); TcpConnectionInformation tcpConnectionInfo = default(TcpConnectionInformation); foreach (TcpConnectionInformation tempLoopVar_tcpConnectionInfo in TCPconnections) { tcpConnectionInfo = tempLoopVar_tcpConnectionInfo; if (tcpConnectionInfo.LocalEndPoint.Port >= lowerLimit & tcpConnectionInfo.LocalEndPoint.Port <= upperLimit) { if (!OpenTCPPorts.ContainsKey(tcpConnectionInfo.LocalEndPoint.Port)) { OpenTCPPorts.Add(tcpConnectionInfo.LocalEndPoint.Port, tcpConnectionInfo.LocalEndPoint.Port); } } } System.Net.IPEndPoint[] endPoints = null; endPoints = properties.GetActiveTcpListeners(); System.Net.IPEndPoint ep = default(System.Net.IPEndPoint); foreach (System.Net.IPEndPoint tempLoopVar_ep in endPoints) { ep = tempLoopVar_ep; if (ep.Port >= lowerLimit & ep.Port <= upperLimit) { if (!OpenTCPPorts.ContainsKey(ep.Port)) { OpenTCPPorts.Add(ep.Port, ep.Port); } } } endPoints = properties.GetActiveUdpListeners(); foreach (System.Net.IPEndPoint tempLoopVar_ep in endPoints) { ep = tempLoopVar_ep; if (ep.Port >= lowerLimit & ep.Port <= upperLimit) { if (!OpenTCPPorts.ContainsKey(ep.Port)) { OpenTCPPorts.Add(ep.Port, ep.Port); } } } return(OpenTCPPorts); }