System.Net.IPAddress.ToString()

Here are the examples of the csharp api System.Net.IPAddress.ToString() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1323 Examples 7

19 Source : AdminController.cs
with Apache License 2.0
from beetlex-io

public object ListConnection(int index, IHttpContext context)
        {
            int size = 20;
            ISession[] sessions = context.Server.BaseServer.GetOnlines();
            int pages = sessions.Length / size;
            if (sessions.Length % size > 0)
                pages++;
            List<object> items = new List<object>();
            for (int i = index * size; i < (index * size + 20) && i < sessions.Length; i++)
            {
                ISession item = sessions[i];
                HttpToken token = (HttpToken)item.Tag;
                items.Add(new
                {
                    item.ID,
                    item.Name,
                    Type = token.WebSocket ? "WebSocket" : "http",
                    CreateTime = DateTime.Now - token.CreateTime,
                    IPAddress = ((System.Net.IPEndPoint)item.RemoteEndPoint).Address.ToString()

                });
            }
            return new { Index = index, Pages = pages, Items = items, context.Server.BaseServer.Count };
        }

19 Source : IPManager.cs
with GNU General Public License v3.0
from berichan

public static string GetIP(ADDRESSFAM Addfam)
    {
        //Return null if ADDRESSFAM is Ipv6 but Os does not support it
        if (Addfam == ADDRESSFAM.IPv6 && !Socket.OSSupportsIPv6)
        {
            return null;
        }

        string output = "";

        foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
        {
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
            NetworkInterfaceType _type1 = NetworkInterfaceType.Wireless80211;
            NetworkInterfaceType _type2 = NetworkInterfaceType.Ethernet;

            if ((item.NetworkInterfaceType == _type1 || item.NetworkInterfaceType == _type2) && item.OperationalStatus == OperationalStatus.Up)
#endif 
            {
                foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
                {
                    //IPv4
                    if (Addfam == ADDRESSFAM.IPv4)
                    {
                        if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
                        {
                            output = ip.Address.ToString();
                        }
                    }

                    //IPv6
                    else if (Addfam == ADDRESSFAM.IPv6)
                    {
                        if (ip.Address.AddressFamily == AddressFamily.InterNetworkV6)
                        {
                            output = ip.Address.ToString();
                        }
                    }
                }
            }
        }
        return output;
    }

19 Source : NetworkInfo.cs
with GNU General Public License v3.0
from berichan

public static void Ping_completed(object s, PingCompletedEventArgs e)
    {
        lock (@lock)
        {
            instances -= 1;
        }

        if (e.Reply.Status == IPStatus.Success)
        {
            UnityEngine.Debug.Log(string.Concat("Active IP: ", e.Reply.Address.ToString()));
            result += 1;
            activeIP.Add(e.Reply.Address.ToString());
        }
        else
        {
            //Debug.Log(String.Concat("Non-active IP: ", e.Reply.Address.ToString()))
        }
    }

19 Source : NetworkInfoAsync.cs
with GNU General Public License v3.0
from berichan

static void p_PingCompleted(object sender, PingCompletedEventArgs e)
    {
        string ip = (string)e.UserState;
        if (e.Reply != null && e.Reply.Status == IPStatus.Success)
        {
            if (resolveNames)
            {
                if (ip == null)
                    ip = e.Reply.Address.ToString();
                var mac = getMacByIp(ip);
                var addit = string.Empty;
                if (idents != null && mac != null)
                {
                    var manufacturer = idents.Find(ByFirst3MacValues(mac));
                    if (manufacturer != string.Empty)
                        addit = manufacturer.Split('\t')[2];
                }

                Console.WriteLine("{0} is up: ({1} ms) ({2}) {3}", ip, e.Reply.RoundtripTime, mac, addit);
                if (addit.StartsWith("Nintendo", StringComparison.OrdinalIgnoreCase))
                    addit = "<color=red>" + addit + "</color>";
                activeIP.Add(string.Format("IP: {0} Manufacturer: {1}", ip, addit));
            }
            else
            {
                Console.WriteLine("{0} is up: ({1} ms)", ip, e.Reply.RoundtripTime);
            }
            lock (lockObj)
            {
                upCount++;
            }
        }
        else if (e.Reply == null)
        {
            Console.WriteLine("Pinging {0} failed. (Null Reply object?)", ip);
        }
        countdown.Signal();
        if (countdown.CurrentCount == 1)
            countdown.Signal(); // Mono pls
    }

19 Source : UseregHelper.cs
with MIT License
from Berrysoft

public async Task<LogResponse> LoginAsync(IPAddress ip) => LogResponse.ParseFromUsereg(await PostAsync(ConnectUri, new Dictionary<string, string>
        {
            ["user_ip"] = ip.ToString(),
            ["drop"] = "0"
        }));

19 Source : UseregHelper.cs
with MIT License
from Berrysoft

public async Task<LogResponse> LogoutAsync(IPAddress ip) => LogResponse.ParseFromUsereg(await PostAsync(InfoUri, string.Format(DropData, ip.ToString())));

19 Source : NetworkClient.cs
with MIT License
from BigBigZBBing

void ICilent.ProcessConnect(SocketAsyncEventArgs e)
        {
            Session session = (Session)e.UserToken;
            if (session.SocketError == SocketError.Success)
            {
                session.UserCode = Guid.NewGuid().ToString("D");
                var EndPoint = (IPEndPoint)session.Client.RemoteEndPoint;
                var AllHost = Dns.GetHostEntry(EndPoint.Address).AddressList;
                session.UserHost = string.Join("|", AllHost.Select(x => x.ToString()).ToArray());
                session.UserPort = EndPoint.Port;
                session.OperationTime = DateTime.Now;
                session.RecHandle.UserToken = session;

                ThreadPool.QueueUserWorkItem(e => OnConnect?.Invoke(session));

                if (Certificate.NotNull())
                {
                    session.SendMessage(Certificate.GetRawCertData());
                }

                if (!session.Client
                        .ReceiveAsync(session.RecHandle))
                    ((ICilent)this).ProcessReceive(session.RecHandle);
            }
            else
            {
                Console.WriteLine($"ProcessConnect:[{session.SocketError.ToString()}]");
            }
        }

19 Source : TcpServer.cs
with MIT License
from BigBigZBBing

void ProcessAccept(SocketAsyncEventArgs e)
        {
            ShakeHandEventArgs eventArgs = (ShakeHandEventArgs)e;

            //接收用户成功
            if (eventArgs.LastOperation == SocketAsyncOperation.Accept && eventArgs.SocketError == SocketError.Success)
            {
                //创建会话信息(当前会话)
                UserTokenSession UserToken = eventArgs.UserToken as UserTokenSession;
                var EndPoint = (IPEndPoint)eventArgs.AcceptSocket.RemoteEndPoint;
                var AllHost = Dns.GetHostEntry(EndPoint.Address).AddressList;
                UserToken.UserHost = string.Join("|", AllHost.Select(x => x.ToString()).ToArray());
                UserToken.UserPort = ((IPEndPoint)(eventArgs.AcceptSocket.RemoteEndPoint)).Port;
                UserToken.Mode = ApplyMode.Server;
                UserToken.OperationTime = DateTime.Now;
                eventArgs.SendEventArgs.SendAction = ProcessSend;
                eventArgs.ReceiveEventArgs.ReceiveAction = ProcessReceive;
                UserToken.ShakeHandEvent = eventArgs;
                OnConnect?.Invoke(UserToken);

                //异步接收客户端行为
                //异步接收客户端消息
                if (!UserToken.Channel.ReceiveAsync(UserToken.ShakeHandEvent.ReceiveEventArgs))
                {
                    ProcessReceive(UserToken.ShakeHandEvent.ReceiveEventArgs);
                }
            }
            else
            {
                //接收用户失败就清理后送回池
                eventArgs.Clear();
                ShakeHandEventPool.Push(eventArgs);
            }
            //继续接收下一个
            ShakeHandAsync();
        }

19 Source : NetworkServer.cs
with MIT License
from BigBigZBBing

void IServer.ProcessAccept(SocketAsyncEventArgs e)
        {
            Session session = (Session)e.UserToken;
            if (e.LastOperation == SocketAsyncOperation.Accept
                && e.SocketError == SocketError.Success)
            {
                session.UserCode = Guid.NewGuid().ToString("D");
                var EndPoint = (IPEndPoint)session.Client.RemoteEndPoint;
                var AllHost = Dns.GetHostEntry(EndPoint.Address).AddressList;
                session.UserHost = string.Join("|", AllHost.Select(x => x.ToString()).ToArray());
                session.UserPort = EndPoint.Port;
                session.OperationTime = DateTime.Now;
                session.RecHandle.UserToken = session;

                OnConnect?.Invoke(session);

                if (!session.Client
                        .ReceiveAsync(session.RecHandle))
                    ((IServer)this).ProcessReceive(session.RecHandle);
            }
            else
            {
                Pool.Enqueue(session);
            }
            ThreadPool.QueueUserWorkItem(e => ((IServer)this).Open());
        }

19 Source : ResolveDnsNameCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

public static CommandResult GetRecords(string domain, string type)
        {
            if (Environment.OSVersion.Platform != PlatformID.Win32NT)
            {
                throw new NotSupportedException();
            }

            CommandResult results = new CommandResult();
            object foundType = RecordTypes[type];
            if (foundType == null)
            {
                string[] types = new string[RecordTypes.Count];
                RecordTypes.Keys.CopyTo(types, 0);
                throw new NoPowerShellException("Invalid type specified. Specify one of the following: {0}.", string.Join(",", types));
            }
            DnsRecordTypes queryType = (DnsRecordTypes)foundType;

            var recordsArray = IntPtr.Zero;
            try
            {
                var result = DnsQuery(ref domain, queryType, DnsQueryOptions.DNS_QUERY_BYPreplaced_CACHE, IntPtr.Zero, ref recordsArray, IntPtr.Zero);
                if (result != 0)
                {
                    throw new Win32Exception(result);
                }

                DNS_RECORD record;
                for (var recordPtr = recordsArray; !recordPtr.Equals(IntPtr.Zero); recordPtr = record.pNext)
                {
                    record = (DNS_RECORD)Marshal.PtrToStructure(recordPtr, typeof(DNS_RECORD));
                    switch (record.wType)
                    {
                        case (ushort)DnsRecordTypes.DNS_TYPE_A:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "A" },
                                    { "IPAddress", ConvertUintToIpAddressString(record.Data.A.IpAddress) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_NS:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "NS" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.NS.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MD:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MD" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MD.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MF:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MF" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MF.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_CNAME:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "CNAME" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.CNAME.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_SOA:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "SOA" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.SOA.pNamePrimaryServer) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MB:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MB" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MB.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MG:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MG" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MG.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MR:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MR" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MR.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_WKS:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "WKS" },
                                    { "Protocol", ((int)record.Data.WKS.chProtocol).ToString() },
                                    { "Mask", ((int)record.Data.WKS.BitMask).ToString() },
                                    { "IPAddress", ConvertUintToIpAddressString(record.Data.WKS.IpAddress) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_PTR:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "PTR" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.PTR.pNameHost) }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_MX:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "MX" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.MX.pNameExchange) },
                                    { "Preference", record.Data.MX.wPreference.ToString() }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_TEXT:
                            for (uint i = 0; i < record.Data.TXT.dwStringCount; i++)
                            {
                                results.Add(
                                    new ResultRecord()
                                    {
                                        { "Name", Marshal.PtrToStringAuto(record.pName) },
                                        { "Type", "TXT" },
                                        { "Strings", Marshal.PtrToStringAuto(record.Data.TXT.pStringArray) },
                                    }
                                );
                            }
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_RT:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "RT" },
                                    { "NameHost", Marshal.PtrToStringAuto(record.Data.RT.pNameExchange) },
                                    { "Preference", record.Data.RT.wPreference.ToString() }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_AAAA:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "AAAA" },
                                    { "IPAddress", ConvertAAAAToIpAddress(record.Data.AAAA).ToString() }
                                }
                            );
                            break;

                        case (ushort)DnsRecordTypes.DNS_TYPE_SRV:
                            results.Add(
                                new ResultRecord()
                                {
                                    { "Name", Marshal.PtrToStringAuto(record.pName) },
                                    { "Type", "SRV" },
                                    { "PrimaryServer", Marshal.PtrToStringAuto(record.Data.SRV.pNameTarget) },
                                }
                            );
                            break;

                        default:
                            throw new Exception(string.Format("Unknown: %s type %d", record.pName, record.wType));
                    }
                }

                return results;
            }
            finally
            {
                if (recordsArray != IntPtr.Zero)
                {
                    DnsRecordListFree(recordsArray, DNS_FREE_TYPE.DnsFreeFlat);
                }
            }
        }

19 Source : ResolveDnsNameCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

public static string ConvertUintToIpAddressString(uint ipAddress)
        {
            return ConvertUintToIpAddress(ipAddress).ToString();
        }

19 Source : GetNetNeighborCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

public override CommandResult Execute(CommandResult pipeIn)
        {
            // The number of bytes needed.
            int bytesNeeded = 0;

            // The result from the API call.
            int result = GetIpNetTable(IntPtr.Zero, ref bytesNeeded, false);

            // Call the function, expecting an insufficient buffer.
            if (result != ERROR_INSUFFICIENT_BUFFER)
                throw new NoPowerShellException("Error in execution: {0}", result);

            // Allocate the memory, do it in a try/finally block, to ensure that it is released.
            IntPtr buffer = IntPtr.Zero;

            // Try/finally.
            try
            {
                // Allocate the memory.
                buffer = Marshal.AllocCoTaskMem(bytesNeeded);

                // Make the call again. If it did not succeed, then raise an error.
                result = GetIpNetTable(buffer, ref bytesNeeded, false);

                // If the result is not 0 (no error), then throw an exception.
                if (result != 0)
                    throw new NoPowerShellException("Error in execution: {0}", result);

                // Now we have the buffer, we have to marshal it. We can read the first 4 bytes to get the length of the buffer.
                int entries = Marshal.ReadInt32(buffer);

                // Increment the memory pointer by the size of the int.
                IntPtr currentBuffer = new IntPtr(buffer.ToInt64() + Marshal.SizeOf(typeof(int)));

                // Allocate an array of entries.
                MIB_IPNETROW[] table = new MIB_IPNETROW[entries];

                // Cycle through the entries.
                for (int index = 0; index < entries; index++)
                {
                    // Call PtrToStructure, getting the structure information.
                    table[index] = (MIB_IPNETROW)Marshal.PtrToStructure(
                        new IntPtr(currentBuffer.ToInt64() + (index * Marshal.SizeOf(typeof(MIB_IPNETROW)))), typeof(MIB_IPNETROW)
                    );
                }

                // Iterate over records and add them to cmdlet result
                for (int index = 0; index < entries; index++)
                {
                    MIB_IPNETROW row = table[index];
                    IPAddress ip = new IPAddress(BitConverter.GetBytes(row.dwAddr));
                    ARPType type = (ARPType)row.dwType;

                    _results.Add(
                        new ResultRecord()
                        {
                            { "ifIndex", row.dwIndex.ToString() },
                            { "IPAddress", ip.ToString() },
                            { "LinkLayerAddress", string.Format("{0:X2}-{1:X2}-{2:X2}-{3:X2}-{4:X2}-{5:X2}", row.mac0, row.mac1, row.mac2, row.mac3, row.mac4, row.mac5) },
                            { "State", type.ToString() }
                        }
                    );
                }
            }
            finally
            {
                // Release the memory.
                FreeMibTable(buffer);
            }

            return _results;
        }

19 Source : TestNetConnectionCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

private static CommandResult PerformTraceroute(string ip, string computerName, int count, int timeout, int maxHops)
        {
            CommandResult results = new CommandResult(count);

            Ping ping = new Ping();
            List<string> IPs = new List<string>(maxHops);

            // Last hop details
            string remoteAddress = string.Empty;
            bool succeeded = false;
            int rtt = -1;

            for (int ttl = 1; ttl <= maxHops; ttl++)
            {
                PingOptions options = new PingOptions(ttl, true);
                PingReply reply = null;

                try
                {
                    reply = ping.Send(ip, timeout, alphabet, options);
                }
                catch(PingException)
                {
                    break;
                }

                if (reply.Status == IPStatus.TtlExpired)
                    IPs.Add(reply.Address.ToString());
                else if (reply.Status == IPStatus.TimedOut)
                    IPs.Add("*");
                else if (reply.Status == IPStatus.Success)
                {
                    IPs.Add(reply.Address.ToString());
                    remoteAddress = reply.Address.ToString();
                    succeeded = true;
                    rtt = (int)reply.RoundtripTime;
                    break;
                }
            }

            ResultRecord record = new ResultRecord()
            {
                { "ComputerName", computerName },
                { "RemoteAddress", remoteAddress },
                { "PingSucceeded", succeeded ? "True" : "False" }
            };

            if(succeeded)
            {
                record.Add("PingReplyDetails (RTT)", rtt.ToString());
                record.Add("TraceRoute", string.Join(", ", IPs.ToArray()));
            }

            results.Add(record);

            return results;
        }

19 Source : TestNetConnectionCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

private static string ResolveIP(string computerName)
        {
            IPHostEntry ip = null;
            try
            {
                ip = Dns.GetHostEntry(computerName);
            }
            catch(SocketException)
            {
                throw new NoPowerShellException("Name resolution of {0} failed", computerName);
            }

            return ip.AddressList[0].ToString();
        }

19 Source : TestNetConnectionCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

private static CommandResult PerformPortTest(string ip, string computerName, int port)
        {
            CommandResult results = new CommandResult(1);

            if (port < 1 || port > 65535)
                throw new NoPowerShellException("Cannot validate argument on parameter 'Port'. The {0} argument is greater than the maximum allowed range of 65535. Supply an argument that is less than or equal to 65535 and then try the command again.", port);

            bool connected = false;
            try
            {
                TcpClient client = new TcpClient(ip, port);
                string address = ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString();
                string localAddress = ((IPEndPoint)client.Client.LocalEndPoint).Address.ToString();
                connected = true;

                results.Add(new ResultRecord()
                {
                    { "ComputerName", computerName },
                    { "RemoteAddress", address},
                    { "RemotePort", port.ToString() },
                    //{ "InterfaceAlias", string.Empty }, // TODO
                    { "SourceAddress", localAddress },
                    { "TcpTestSucceeded", connected ? "True" : "False" }
                });
            }
            catch(SocketException)
            {
                throw new NoPowerShellException("TCP connect to ({0} : {1}) failed", ip, port);
            }

            return results;
        }

19 Source : TestNetConnectionCommand.cs
with BSD 3-Clause "New" or "Revised" License
from bitsadmin

private static CommandResult PerformPing(string ip, string computerName, int count, int timeout, int ttl)
        {
            CommandResult results = new CommandResult(count);

            Ping ping = new Ping();
            PingOptions options = new PingOptions(ttl, false);

            bool succeeded = false;

            for (int i = 0; i < count; i++)
            {
                PingReply reply = null;

                try
                {
                    reply = ping.Send(ip, timeout, alphabet, options);
                }
                catch(PingException)
                {
                    break;
                }

                succeeded = true;

                // Add to output
                results.Add(
                    new ResultRecord()
                    {
                        { "ComputerName", computerName },
                        { "RemoteAddress", (reply.Address != null) ? reply.Address.ToString() : null },
                        { "PingSucceeded", reply.Status == IPStatus.Success ? "True" : "False" },
                        { "PingReplyDetails (RTT)", reply.RoundtripTime.ToString() }
                    }
                );

                // Send only 1 request per second
                //if (i != count - 1)
                //    Thread.Sleep(1000 - (int)reply.RoundtripTime);
            }

            // Error response
            if (!succeeded)
            {
                results.Add(new ResultRecord()
                {
                    { "ComputerName", computerName },
                    { "RemoteAddress", string.Empty },
                    { "PingSucceeded", succeeded ? "True" : "False" }
                });
            }

            return results;
        }

19 Source : MinecraftClientConnection.cs
with GNU Lesser General Public License v2.1
from Blancworks

private static async Task HandshakePacketHandler(byte[] data, MemoryStream stream, MinecraftClientConnection connection)
        {
            HandshakePacket packet = new HandshakePacket();
            await packet.Read(stream);

            connection.state = packet.nextState;
            Logger.LogMessage("Handshake with state " + packet.nextState);

            Logger.LogMessage("IP is " + ((IPEndPoint)connection.client.Client.RemoteEndPoint).Address.ToString());
        }

19 Source : Worker-Server.cs
with MIT License
from BlazorPlus

internal async Task AcceptConnectorAndWorkAsync(Socket clientSock, CommandMessage connmsg)
		{
			bool supportEncrypt = _worker.Server.UseEncrypt;
			if (connmsg.Args[4] == "0") supportEncrypt = false;

			byte[] clientKeyIV;
			try
			{
				_worker.Server.ConnectorLicense.DescriptSourceKey(Convert.FromBase64String(connmsg.Args[2]), Convert.FromBase64String(connmsg.Args[3]), out clientKeyIV);
			}
			catch (Exception x)
			{
				_worker.OnError(x);
				var failedmsg = new CommandMessage("ConnectFailed", "InvalidSecureKey");
				await clientSock.SendAsync(failedmsg.Pack(), SocketFlags.None);
				return;
			}

			TcpMapServerClient sclient = _worker.FindClient();
			if (sclient == null)
			{
				var failedmsg = new CommandMessage("ConnectFailed", "NoClient");
				await clientSock.SendAsync(failedmsg.Pack(), SocketFlags.None);
				return;
			}

			string mode = connmsg.Args[5];
			string connArgument = connmsg.Args[6];
			if (mode == "USB")//use server bandwidth
			{
				var resmsg = new CommandMessage("ConnectOK", "ConnectOK", supportEncrypt ? "1" : "0");
				await clientSock.SendAsync(resmsg.Pack(), SocketFlags.None);

				Stream _sread, _swrite;
				if (supportEncrypt)
				{
					_worker.Server.ConnectorLicense.OverrideStream(clientSock.CreateStream(), clientKeyIV, out _sread, out _swrite);
				}
				else
				{
					_sread = _swrite = clientSock.CreateStream();
				}

				using Socket localsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
				string ip = _worker.Server.ServerBind;
				if (ip == "0.0.0.0") ip = "127.0.0.1";
				localsock.InitTcp();
				await localsock.ConnectAsync(ip, _worker.Server.ServerPort);

				TcpMapConnectorSession session = new TcpMapConnectorSession(new SimpleSocketStream(localsock));
				await session.DirectWorkAsync(_sread, _swrite);
			}
			else if (mode == "UDP")
			{
				if (_udpcache == null)
				{
					lock (typeof(TcpMapServerConnector))
					{
						if (_udpcache == null)
						{
							var opt = new MemoryCacheOptions();
							Microsoft.Extensions.Options.IOptions<MemoryCacheOptions> iopt = Microsoft.Extensions.Options.Options.Create(opt);
							_udpcache = new MemoryCache(iopt);
						}

					}
				}

				UdpInfoItem natinfo;
				string key = connArgument + ":" + sclient.SessionId;
				if (!_udpcache.TryGetValue(key, out natinfo) || natinfo.HasExpired())
				{
					var udpmsg = await sclient.CreateUDPNatAsync(connArgument);
					string[] pair = udpmsg.Args[1].Split(':');
					string addr = pair[0];
					int port = int.Parse(pair[1]);
					natinfo = new UdpInfoItem(addr + ":" + port);
					_udpcache.Set(key, natinfo);
				}



				var resmsg = new CommandMessage("ConnectOK", "ConnectOK", supportEncrypt ? "1" : "0", natinfo.NatInfo);
				await clientSock.SendAsync(resmsg.Pack(), SocketFlags.None);

				resmsg = await CommandMessage.ReadFromSocketAsync(clientSock);
				if (resmsg == null)
					return;
				throw new NotImplementedException("work for " + resmsg);
			}
			else if (mode == "RCP")
			{

				var resmsg = new CommandMessage("ConnectOK", "ConnectOK", supportEncrypt ? "1" : "0"
					, ((IPEndPoint)sclient._socket.RemoteEndPoint).Address.ToString(), sclient.OptionRouterClientPort.ToString());
				await clientSock.SendAsync(resmsg.Pack(), SocketFlags.None);
			}
			else
			{
				throw new NotImplementedException();
			}
		}

19 Source : NetworkConfigurations.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public string GetResolvedIp()
        {
            if (IPAddress.TryParse(PublicIpAddress, out var address) && address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) return PublicIpAddress;
            
            var resolvedIp = Dns.GetHostEntry(PublicIpAddress).AddressList.First(addr => addr.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
            return resolvedIp?.ToString() ?? PublicIpAddress;
        }

19 Source : TcpConnectionTester.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task<Peer> TestListen(IPEndPoint remoteEndPoint)
        {
            _lastUsage = DateTime.UtcNow;

            if (_connections.Contains((ip) => ip.Address.ToString() == remoteEndPoint.Address.ToString())) return null;

            var peerConnection = _peerConnectionsHandler.CurrentPeerConnections.GetEnumerable().Where(p => p.IPEndPoint.Address.ToString() == remoteEndPoint.Address.ToString() && p.IPEndPoint.Port == remoteEndPoint.Port).SingleOrDefault();

            _networkService.SubscribePeerConnectedEvent(TcpConnector_PeerConnected);
            _networkService.SubscribePongReceivedEvent(MessageForwarder_PongMessageReceived);

            if (peerConnection != null)
            {
                _logger.LogInformation($"Using existing peer connection to {peerConnection.Peer.EndPoint.Address.ToString()}:{peerConnection.Peer.EndPoint.Port}");
                PrepareAndSendData(peerConnection.Peer);
                return peerConnection.Peer;
            }

            _logger.LogInformation($"Trying to connect to {remoteEndPoint.Address.ToString()}:{remoteEndPoint.Port}");

            try
            {
                var peer = await _networkService.ConnectAsync(remoteEndPoint);//, new IPEndPoint(_systemConfig.IPAddress, _systemConfig.TcpPort));
                return peer;
            }
            catch (Exception)
            {
                _networkService.UnSubscribePeerConnectedEvent(TcpConnector_PeerConnected);
                _networkService.UnSubscribePongReceivedEvent(MessageForwarder_PongMessageReceived);
                return null;
            }
        }

19 Source : TcpConnectionTester.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

private async Task SendDataUntilPeerExists(int number, TimeSpan delayBetweenMessages, IPEndPoint ipEndPoint)
        {

            try
            {
                if (!_connections.Contains((ip) => ip.Address.ToString() == ipEndPoint.Address.ToString())) return;

                var bytes = Encoding.Unicode.GetBytes($"Hello message #{number} from {_systemConfig.IPAddress}");
                byte[] payload = BitConverter.GetBytes(number);
                var type = NetworkMessageTypeEnum.Ping;
                string endPoint = _systemConfig.IPAddress + ":" + _systemConfig.TcpPort;
                var message = new NetworkMessage(type, payload, TransportTypeEnum.Tcp, _nodeConfigurations.ActivePrivateKey, _nodeConfigurations.ActivePublicKey, endPoint, _nodeConfigurations.AccountName, ipEndPoint);
                await _networkService.SendMessageAsync(message);
                _logger.LogInformation($"Sent ping message #{number}");
                await Task.Delay(delayBetweenMessages);
                SendDataUntilPeerExists(number + 1, delayBetweenMessages, ipEndPoint);
            }
            catch
            {
                _logger.LogInformation("Failed to send message");
            }
        }

19 Source : TcpConnectionTester.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

private void MessageForwarder_PongMessageReceived(PongReceivedEventArgs args, IPEndPoint sender)
        {
            _logger.LogInformation($"Received pong message from {sender.Address.ToString()} with number: {args.nonce}");
        }

19 Source : TcpConnectionTester.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

private void MessageForwarder_PingMessageReceived(PingReceivedEventArgs args, IPEndPoint sender)
        {
            //check if the nounce is between 0 and 20 so it doesn't print other ping messages used to maintain connections open
            if (args.nonce > 0 && args.nonce <= 20)
                _logger.LogInformation($"Received ping message from {sender.Address.ToString()}:{sender.Port} with number: {args.nonce}");
        }

19 Source : TransactionValidationsHandler.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

private async void MessageForwarder_TransactionsReceived(MessageForwarder.TransactionsReceivedEventArgs args, IPEndPoint sender)
        {
            try
            {
                _logger.LogDebug($"Receiving transaction for sidechain: {args.ClientAccountName}");
                var transactionsProto = SerializationHelper.DeserializeTransactions(args.TransactionsBytes, _logger);

                if (!_sidechainKeeper.TryGet(args.ClientAccountName, out var sidechainContext))
                {
                    _logger.LogDebug($"Transaction received but sidechain {args.ClientAccountName} is unknown.");
                    return;
                }

                if (transactionsProto == null) return;

                var receivedValidTransactions = new List<ulong>();
                var containsUnsavedTransactions = false;
                _logger.LogInformation($"Received transaction #{transactionsProto.FirstOrDefault()?.SequenceNumber} to #{transactionsProto.LastOrDefault()?.SequenceNumber} for sidechain {args.ClientAccountName}");

                foreach (var transactionProto in transactionsProto)
                {
                    if (receivedValidTransactions.Contains(transactionProto.SequenceNumber))
                        continue;

                    var transaction = new Transaction().SetValuesFromProto(transactionProto);
                    if (await ValidateTransaction(transaction, args.ClientAccountName, sidechainContext))
                    {
                        var isTransactionAlreadySaved = await CheckIfAlreadySavedTransactionAndSave(args.ClientAccountName, transaction);
                        if (!isTransactionAlreadySaved && !containsUnsavedTransactions) containsUnsavedTransactions = true;
                        receivedValidTransactions.Add(transaction.SequenceNumber);
                    }
                }

                if (!receivedValidTransactions.Any()) return;

                var lastTransaction = new Transaction().SetValuesFromProto(transactionsProto.Last());
                var alreadyReceivedTrxAfterLast = await GetConfirmedTransactionsSequeceNumber(lastTransaction, args.ClientAccountName);
                if (alreadyReceivedTrxAfterLast.Count > 0)
                    receivedValidTransactions.AddRange(alreadyReceivedTrxAfterLast);

                var data = new List<byte>();
                foreach (var transactionSequenceNumber in receivedValidTransactions)
                    data.AddRange(BitConverter.GetBytes(transactionSequenceNumber));

                var requesterPeer = _peerConnectionsHandler.CurrentPeerConnections.GetEnumerable().Where(p => p.ConnectionAccountName == args.ClientAccountName).FirstOrDefault();
                if (requesterPeer?.IPEndPoint?.Address.ToString() == sender.Address.ToString() && requesterPeer?.IPEndPoint?.Port == sender.Port)
                {
                    var message = new NetworkMessage(
                        NetworkMessageTypeEnum.ConfirmTransactionReception,
                        data.ToArray(),
                        TransportTypeEnum.Tcp, _nodeConfigurations.ActivePrivateKey,
                        _nodeConfigurations.ActivePublicKey,
                        _networkConfigurations.GetResolvedIp() + ":" + _networkConfigurations.TcpPort,
                        _nodeConfigurations.AccountName, sender);
                    _logger.LogDebug("Sending confirmation transaction.");
                    await _networkService.SendMessageAsync(message);
                }

                //TODO: Temporarily remove logic, to replace with asking for transactions
                // if (containsUnsavedTransactions)
                // {
                //     await SendTransactionsToConnectedProviders(transactionsProto, args.ClientAccountName, sender, sidechainContext);
                // }
            }
            catch (Exception e)
            {
                _logger.LogError("Error handling received transactions");
                _logger.LogDebug($"Exception: {e}");
            }
        }

19 Source : TransactionValidationsHandler.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

private async Task SendTransactionsToConnectedProviders(IEnumerable<TransactionProto> transactions, string clientAccountName, IPEndPoint sender, SidechainContext sidechainContext)
        {
            var data = new List<byte>();
            var sidechainNameBytes = Encoding.UTF8.GetBytes(clientAccountName);
            short lenght = (short)sidechainNameBytes.Length;
            data.AddRange(BitConverter.GetBytes(lenght));
            data.AddRange(sidechainNameBytes);
            foreach (var transaction in transactions)
            {
                var transactionBytes = transaction.ToByteArray();
                data.AddRange(BitConverter.GetBytes(transactionBytes.Count()));
                data.AddRange(transactionBytes);
            }

            var sendTransactionTasks = new List<Task>();
            foreach (var producer in sidechainContext.SidechainPool.ProducersInPool.GetEnumerable().Where(p => p.PeerConnection != null && p.PeerConnection.ConnectionState == ConnectionStateEnum.Connected && p.PeerConnection.IPEndPoint != null))
            {
                if (producer.PeerConnection.IPEndPoint.Address.ToString() == sender.Address.ToString() && producer.PeerConnection.IPEndPoint.Port == sender.Port) continue;
                var message = new NetworkMessage(NetworkMessageTypeEnum.SendTransactions, data.ToArray(), TransportTypeEnum.Tcp, _nodeConfigurations.ActivePrivateKey, _nodeConfigurations.ActivePublicKey, _networkConfigurations.GetResolvedIp() + ":" + _networkConfigurations.TcpPort, _nodeConfigurations.AccountName, producer.PeerConnection.IPEndPoint);

                _logger.LogDebug($"Sending transactions #{transactions?.First()?.SequenceNumber} to #{transactions?.Last()?.SequenceNumber} to producer {producer.PeerConnection.ConnectionAccountName}");
                sendTransactionTasks.Add(_networkService.SendMessageAsync(message));
            }
            await Task.WhenAll(sendTransactionTasks);
        }

19 Source : NetworkService.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task<OpResult<NetworkMessage>> ReceiveMessage(NetworkMessageTypeEnum type, IPEndPoint receiveFrom)
        {
            bool messageValidator(NetworkMessage networkMessage)
            {
                return (networkMessage.Sender.Address.ToString() == receiveFrom.Address.ToString() && receiveFrom.Port == networkMessage.Sender.Port);
            }

            return await MessageForwarder.RegisterMessageEvent(type, messageValidator, null);
        }

19 Source : CommunicationManager.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public bool IsConnectedTo(IPEndPoint endpoint)
        {
            return _peers.Keys.Any(k => k.Address.ToString() == endpoint.Address.ToString() && k.Port == endpoint.Port);
        }

19 Source : CommunicationManager.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public Peer GetPeerIfExists(IPEndPoint endpoint)
        {
            var key = _peers.Keys.Where(k => k.Address.ToString() == endpoint.Address.ToString() && k.Port == endpoint.Port).FirstOrDefault();

            if (key != null)
            {
                _peers.TryGetValue(key, out var peer);
                return peer;
            }

            return null;
        }

19 Source : NetworkQuery.cs
with GNU General Public License v3.0
from blueminder

public static Dictionary<String, String> GetIPsByNetwork()
        {
            var IPsByNetwork = new Dictionary<String, String>();

            var externalIP = GetExternalIP();
            if (externalIP != null)
                IPsByNetwork.Add("External", externalIP);

            NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

            foreach (NetworkInterface network in networkInterfaces)
            {
                IPInterfaceProperties properties = network.GetIPProperties();
                foreach (IPAddressInformation address in properties.UnicastAddresses)
                {
                    if (address.Address.AddressFamily != AddressFamily.InterNetwork)
                        continue;

                    if (IPAddress.IsLoopback(address.Address))
                        continue;

                    IPsByNetwork[network.Name] = address.Address.ToString();
                }
            }

            return IPsByNetwork;
        }

19 Source : NukiBridge2MqttLogic.cs
with Apache License 2.0
from bluewalk

private void Initialize(string mqttHost, int? mqttPort, string mqttRootTopic, string callbackAddress,
            int? callbackPort, string bridgeUrl, string token, bool hashToken, int? infoInterval)
        {
            _mqttRootTopic = !string.IsNullOrEmpty(mqttRootTopic) ? mqttRootTopic : "nukibridge";
            _mqttHost = !string.IsNullOrEmpty(mqttHost) ? mqttHost : "localhost";
            _mqttPort = mqttPort ?? 1883;

            _bridgeUrl = !string.IsNullOrEmpty(bridgeUrl) ? bridgeUrl : NukiBridgeClient.DiscoverBridge();
            _bridgeToken = token;

            if (string.IsNullOrEmpty(_bridgeUrl) ||
                string.IsNullOrEmpty(_bridgeToken))
                throw new Exception("No Bridge_URL and/or Bridge_Token defined");

            _hashToken = hashToken;

            // Setup MQTT
            _mqttClient = new MqttFactory().CreateManagedMqttClient();
            _mqttClient.UseApplicationMessageReceivedHandler(e => MqttClientOnApplicationMessageReceived(e));
            _mqttClient.UseConnectedHandler(e =>
            {
                Log.Information("MQTT: Connected");

                SubscribeTopic("discover");
                SubscribeTopic("reset");
                SubscribeTopic("reboot");
                SubscribeTopic("fw-upgrade");
            });
            _mqttClient.UseDisconnectedHandler(e =>
            {
                if (e.ClientWasConnected)
                    Log.Warning($"MQTT: Disconnected ({e.Exception?.Message ?? "clean"})");
                else
                    Log.Error($"MQTT: Unable to connect ({e.Exception?.Message ?? "clean"})");
            });

            _nukiBridgeClient = new NukiBridgeClient(_bridgeUrl, _bridgeToken, _hashToken);

            // Setup callback
            _callbackAddress = callbackAddress ?? LocalIpAddress().ToString();
            _callbackPort = callbackPort ?? 8080;
            
            _httpListener = new HttpListener
            {
                Prefixes = { $"http://+:{_callbackPort}/" }
            };

            _devices = new List<Device>();

            // Prevent info interval being set to 0
            if ((infoInterval ?? 0) == 0)
                infoInterval = 300;
                
            // Setup info interval
            _infoTimer = new Timer((infoInterval ?? 300) * 1000);
            _infoTimer.Elapsed += async (sender, args) =>
            {
                _infoTimer.Stop();
                await PublishBridgeInfo();
                _infoTimer.Start();
            };
        }

19 Source : MainForm.cs
with GNU General Public License v2.0
from bmachuletz

private void GenerateCertificateButton_Click(object sender, EventArgs e)
        {
            tEngine = new replacedaniumEngine();
            FileServer filerserver = new FileServer();

            GenerateCertificateButton.Enabled = false;
            StartProxyButton.Enabled = true;
            
            var host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (var ip in host.AddressList)
            {
                if (ip.AddressFamily == AddressFamily.InterNetwork)
                {
                    if (!ip.ToString().Contains("169.254"))
                    {
                        LinkLabel linkLabel = new LinkLabel();
                        linkLabel.AutoSize = true;
                    
                        linkLabel.Text = string.Format("http://{0}/Temporary_Listen_Addresses/", ip.ToString());
                        ipAdressPanel.Controls.Add(linkLabel);
                        linkLabel.Click += LinkLabel_Click;
                    }
                }
            }

            ipAdressPanel.Visible = true;
            downloadToPhoneLabel.Visible = true;

            StartProxyButton.Visible = true;
        }

19 Source : BaseManager.cs
with GNU General Public License v3.0
from boonkerz

public void Connect(String host, int port)
		{
            IPAddress[] addresslist = Dns.GetHostAddresses(host);

            _netManager.Connect(addresslist[0].ToString(), port);
		}

19 Source : IPAddressArrayToStringConverter.cs
with GNU General Public License v3.0
from BornToBeRoot

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
                return "-/-";

            if (!(value is IPAddress[] ipAddresses))
                return "-/-";

            var result = string.Empty;

            foreach (var ipAddr in ipAddresses)
            {
                if (!string.IsNullOrEmpty(result))
                    result += Environment.NewLine;

                result += ipAddr.ToString();
            }

            return result;
        }

19 Source : IPAddressSubnetmaskTupleArrayToStringConverter.cs
with GNU General Public License v3.0
from BornToBeRoot

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
                return "-/-";

            if (!(value is Tuple<IPAddress, IPAddress>[] ipAddresses))
                return "-/-";

            var result = string.Empty;

            foreach (var ipAddr in ipAddresses)
            {
                if (!string.IsNullOrEmpty(result))
                    result += Environment.NewLine;

                result += ipAddr.Item1.ToString() + "/" + Subnetmask.ConvertSubnetmaskToCidr(ipAddr.Item2);
            }

            return result;
        }

19 Source : IPAddressToStringConverter.cs
with GNU General Public License v3.0
from BornToBeRoot

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return !(value is IPAddress) ? "-/-" : ((IPAddress)value).ToString();
        }

19 Source : IPScanner.cs
with GNU General Public License v3.0
from BornToBeRoot

public void ScanAsync(IPAddress[] ipAddresses, CancellationToken cancellationToken)
		{
			// Start the scan in a separat task
			Task.Run(() =>
			{
				_progressValue = 0;

				// Create dns client and set options

				if (ResolveHostname)
				{
					DnsLookupClient = UseCustomDNSServer ? new LookupClient(new IPEndPoint(CustomDNSServer, CustomDNSPort)) : new LookupClient();
					DnsLookupClient.UseCache = DNSUseCache;
					DnsLookupClient.Recursion = DNSRecursion;
					DnsLookupClient.Timeout = DNSTimeout;
					DnsLookupClient.Retries = DNSRetries;
					DnsLookupClient.UseTcpOnly = DNSUseTCPOnly;
				}

				// Modify the ThreadPool for better performance
				ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
				ThreadPool.SetMinThreads(workerThreads + Threads, completionPortThreads + Threads);

				try
				{
					var parallelOptions = new ParallelOptions
					{
						CancellationToken = cancellationToken,
						MaxDegreeOfParallelism = Threads
					};

					Parallel.ForEach(ipAddresses, parallelOptions, ipAddress =>
					 {
						 var pingInfo = new PingInfo();
						 var pingable = false;

						 // PING
						 using (var ping = new System.Net.NetworkInformation.Ping())
						 {
							 for (var i = 0; i < ICMPAttempts; i++)
							 {
								 try
								 {
									 var pingReply = ping.Send(ipAddress, ICMPTimeout, ICMPBuffer);

									 if (pingReply != null && IPStatus.Success == pingReply.Status)
									 {
										 if (ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
											 pingInfo = new PingInfo(pingReply.Address, pingReply.Buffer.Length, pingReply.RoundtripTime, pingReply.Options.Ttl, pingReply.Status);
										 else
											 pingInfo = new PingInfo(pingReply.Address, pingReply.Buffer.Length, pingReply.RoundtripTime, pingReply.Status);

										 pingable = true;
										 break; // Continue with the next checks...
									 }

									 if (pingReply != null)
										 pingInfo = new PingInfo(ipAddress, pingReply.Status);
								 }
								 catch (PingException)
								 { }

								 // Don't scan again, if the user has canceled (when more than 1 attempt)
								 if (cancellationToken.IsCancellationRequested)
									 break;
							 }
						 }

						 if (pingable || ShowScanResultForAllIPAddresses)
						 {
							 // DNS
							 var hostname = string.Empty;

							 if (ResolveHostname)
							 {
								 try
								 {
									 var dnsQueryResponse = DnsLookupClient.QueryReverse(ipAddress);

									 if (dnsQueryResponse != null && !dnsQueryResponse.HasError)
										 hostname = dnsQueryResponse.Answers.PtrRecords().FirstOrDefault()?.PtrDomainName;
									 else
										 hostname = DNSShowErrorMessage ? dnsQueryResponse.ErrorMessage : "";
								 }
								 catch (Exception ex)
								 {
									 hostname = DNSShowErrorMessage ? ex.Message : "";
								 }
							 }

							 // ARP
							 PhysicalAddress macAddress = null;
							 var vendor = string.Empty;

							 if (ResolveMACAddress)
							 {
								 // Get info from arp table
								 var arpTableInfo = ARP.GetTable().FirstOrDefault(p => p.IPAddress.ToString() == ipAddress.ToString());

								 if (arpTableInfo != null)
									 macAddress = arpTableInfo.MACAddress;

								 // Check if it is the local mac
								 if (macAddress == null)
								 {
									 var networkInferfaceInfo = NetworkInterface.GetNetworkInterfaces().FirstOrDefault(p => p.IPv4Address.Any(x => x.Item1.Equals(ipAddress)));

									 if (networkInferfaceInfo != null)
										 macAddress = networkInferfaceInfo.PhysicalAddress;
								 }

								 // Vendor lookup
								 if (macAddress != null)
								 {
									 var info = OUILookup.Lookup(macAddress.ToString()).FirstOrDefault();

									 if (info != null)
										 vendor = info.Vendor;
								 }
							 }

							 OnHostFound(new HostFoundArgs(pingInfo, hostname, macAddress, vendor));
						 }

						 IncreaseProcess();
					 });


					OnScanComplete();
				}
				catch (OperationCanceledException)  // If user has canceled
				{
					// Check if the scan is already complete...
					if (ipAddresses.Length == _progressValue)
						OnScanComplete();
					else
						OnUserHasCanceled();
				}
				finally
				{
					// Reset the ThreadPool to default
					ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads);
					ThreadPool.SetMinThreads(workerThreads - Threads, completionPortThreads - Threads);
				}
			}, cancellationToken);
		}

19 Source : Traceroute.cs
with GNU General Public License v3.0
from BornToBeRoot

public void TraceAsync(IPAddress ipAddress, CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                for (var i = 1; i < MaximumHops + 1; i++)
                {
                    var tasks = new List<Task<Tuple<PingReply, long>>>();

                    for (var y = 0; y < 3; y++)
                    {
                        var i1 = i;

                        tasks.Add(Task.Run(() =>
                        {
                            var stopwatch = new Stopwatch();

                            PingReply pingReply;

                            using (var ping = new System.Net.NetworkInformation.Ping())
                            {
                                stopwatch.Start();

                                pingReply = ping.Send(ipAddress, Timeout, Buffer, new PingOptions { Ttl = i1, DontFragment = DontFragement });

                                stopwatch.Stop();
                            }

                            return Tuple.Create(pingReply, stopwatch.ElapsedMilliseconds);
                        }, cancellationToken));
                    }

                    // ReSharper disable once CoVariantArrayConversion, no write operation
                    Task.WaitAll(tasks.ToArray());

                    var ipAddressHop = tasks.FirstOrDefault(x => x.Result.Item1 != null)?.Result.Item1.Address;

                   // Resolve Hostname
                    var hostname = string.Empty;

                    if (ResolveHostname && ipAddressHop != null)
                    {
                        try
                        {
                            var answer = await DnsLookupClient.GetHostNameAsync(ipAddressHop);

                            if (!string.IsNullOrEmpty(answer))
                                hostname = answer;
                        }
                        catch { } // Couldn't resolve hostname
                    }

                    OnHopReceived(new TracerouteHopReceivedArgs(i, tasks[0].Result.Item2, tasks[1].Result.Item2, tasks[2].Result.Item2, ipAddressHop, hostname, tasks[0].Result.Item1.Status, tasks[1].Result.Item1.Status, tasks[2].Result.Item1.Status));

                    // Check if finished
                    if (ipAddressHop != null && ipAddress.ToString() == ipAddressHop.ToString())
                    {
                        OnTraceComplete();
                        return;
                    }

                    // Check for cancel
                    if (!cancellationToken.IsCancellationRequested)
                        continue;

                    OnUserHasCanceled();

                    return;
                }

                // Max hops reached...
                OnMaximumHopsReached(new MaximumHopsReachedArgs(MaximumHops));

            }, cancellationToken);
        }

19 Source : Subnetmask.cs
with GNU General Public License v3.0
from BornToBeRoot

public static int ConvertSubnetmaskToCidr(IPAddress subnetmask)
        {
            return string.Join("", IPv4Address.ToBinaryString(subnetmask.ToString()).Replace(".", "").TrimEnd('0')).Length;
        }

19 Source : MainForm.cs
with MIT License
from bp2008

private void AddPingTarget(IPAddress ipAddress, string name)
		{
			if (ipAddress == null)
				return;
			try
			{
				if (panel_Graphs.InvokeRequired)
					panel_Graphs.Invoke((Action<IPAddress, string>)AddPingTarget, ipAddress, name);
				else
				{
					int id = graphSortingCounter++;
					PingGraphControl graph = new PingGraphControl(this.settings);

					pingTargets.Add(id, ipAddress);
					pingGraphs.Add(id, graph);
					ResetGraphTimestamps();
					pingTargetHasAtLeastOneSuccess.Add(id, false);

					string ipString = ipAddress.ToString();
					if (!string.IsNullOrEmpty(name))
					{
						if (ipString == name)
							graph.DisplayName = name;
						else
							graph.DisplayName = name + " [" + ipString + "]";
					}
					else
						graph.DisplayName = ipString;

					graph.AlwaysShowServerNames = cbAlwaysShowServerNames.Checked;
					graph.Threshold_Bad = (int)nudBadThreshold.Value;
					graph.Threshold_Worse = (int)nudWorseThreshold.Value;
					graph.ShowLastPing = cbLastPing.Checked;
					graph.ShowAverage = cbAverage.Checked;
					graph.ShowJitter = cbJitter.Checked;
					graph.ShowMinMax = cbMinMax.Checked;
					graph.ShowPacketLoss = cbPacketLoss.Checked;

					panel_Graphs.Controls.Add(graph);
					AddEventHandlers(graph);
					panel_Graphs_Resize(null, null);
				}
			}
			catch (Exception ex)
			{
				if (!(ex.InnerException is ThreadAbortException))
					CreateLogEntry(ex.ToString());
			}
		}

19 Source : NetworkScanner.cs
with MIT License
from bp2008

private string IdentifyHost(IPAddress ip, out HttpResponseData response)
		{
			response = null;
			Stopwatch sw = new Stopwatch();
			try
			{
				sw.Start();
				response = HttpHelper.GetHttpResponseData("http://" + ip.ToString() + "/");
				if (response.GetHeaderValue("server").StartsWith("lighttpd") && response.GetHeaderValue("set-cookie").Contains("AIROS_") && response.data.Contains("<replacedle>Error 404"))
					return "Ubiquiti";
				else if (response.GetHeaderValue("server").StartsWith("Boa") && response.data.Contains("<OBJECT ID=\"TSConfigIPCCtrl\""))
					return "Generic IP Cam"; // CCDCam EC-IP5911
				else if (response.data.Contains("flow_slct = get_slctid('flowtype');"))
					return "IPS Cam";
				else if (response.GetHeaderValue("server") == "GoAhead-Webs" && response.data.Contains("doreplacedent.location = '/live.asp?"))
					return "Edimax Cam";
				else if (response.GetHeaderValue("server").StartsWith("App-webs/") && response.data.Contains("window.location.href = \"doc/page/login.asp"))
					return "Hikvision";
				else if (response.data.Contains("src=\"jsCore/LAB.js\"") || response.data.Contains("var lt = \"?WebVersion=") || response.data.Contains("src=\"jsCore/rpcCore.js"))
					return "Dahua";
				else if (response.GetHeaderValue("www-authenticate").Contains("realm=\"tomato\""))
					return "Tomato";
				else if (response.GetHeaderValue("server") == "Web Server" && response.data.Contains("<replacedLE>NETGEAR FS728TP</replacedLE>"))
					return "Netgear FS728TP";
				else if (response.GetHeaderValue("set-cookie").Contains("DLILPC=") && response.data.Contains("<replacedle>Power Controller"))
					return "Web Power Switch";
				else if (response.data == "The server committed a protocol violation. Section=ResponseStatusLine")
					return "? WeatherDirect ?";
				else if (response.data == "The server committed a protocol violation. Section=ResponseHeader Detail=CR must be followed by LF")
					return "? Web Power Switch ?";
				else if (response.data.Contains("NetDAQ ND-100"))
					return "NetDAQ ND-100";
				else if (response.GetHeaderValue("server") == "nginx" && response.data.Contains("<replacedle>airVision:"))
					return "AirVision NVR";
				else if (response.GetHeaderValue("server") == "nginx" && response.data.Contains("<replacedle>airVision:"))
					return "AirVision NVR";
				else if (response.GetHeaderValue("server").StartsWith("BlueIris-"))
					return "Blue Iris";
				//else if (response.data.Contains("<replacedle>iTach"))
				//	return "iTach";
				else if (response.data.Contains("href=\"/cmh\""))
					return "Vera";
				else if (response.data.Contains("WDMyCloud"))
					return "WDMyCloud";
				//else if (response.data.Contains("<replacedle>DD-WRT"))
				//	return "DD-WRT";
				else if (response.data.Contains("= \"Peplink\""))
					return "Peplink";
				else if (response.data.Contains("GSViewerX.ocx"))
					return "GrandStream";
				else if (response.data.Contains("content=\"Canon Inc.\""))
					return "Canon printer";
				else if (response.GetHeaderValue("server") == "tsbox" && response.GetHeaderValue("www-authenticate") == "Basic realm=\"pbox\"")
					return "HDMI Encoder";
				else if (response.data.Contains("Rules of login preplacedword.\\n"))
					return "ACTi";
				else if (response.data.Contains("/static/freenas_favicon.ico"))
					return "FreeNAS";
				else if (response.data.Contains("CONTENT=\"0;url=cgi-bin/kvm.cgi\""))
					return "Avocent KVM";
				else if (response.GetHeaderValue("www-authenticate") == "Basic realm=\"TomatoUSB\"")
					return "TomatoUSB Router";
				else if (response.GetHeaderValue("auther") == "Steven Wu" && response.GetHeaderValue("server") == "Camera Web Server/1.0" && response.data.Contains("location.href=\"top.htm?Currenttime=\"+timeValue;"))
					return "TrendNET IP cam";
				else if (response.data.Contains(@"<meta http-equiv=""refresh"" content=""0;URL='/ui'""/>"))
					return "ESXi";
				else if (response.GetHeaderValue("server") == "Microsoft-HTTPAPI/2.0")
					return "IIS";
				else
				{
					Match m = rxHtmlreplacedle.Match(response.data);
					if (m.Success)
						return m.Groups[1].Value;
					string server = response.GetHeaderValue("server");
					if (!string.IsNullOrEmpty(server))
						return server;
					return "";
				}
				return response.data;
			}
			catch (Exception)
			{
			}
			finally
			{
				sw.Stop();
				//Console.WriteLine("Spent " + sw.ElapsedMilliseconds + " on " + response.data.Length);
			}
			return "";
		}

19 Source : MainForm.cs
with MIT License
from bp2008

void pinger_PingCompleted(object sender, PingCompletedEventArgs e)
		{
			try
			{
				object[] args = (object[])e.UserState;
				DateTime time = (DateTime)args[0];
				long pingNum = (long)args[1];

				PingGraphControl graph = (PingGraphControl)args[2];
				int pingTargetId = (int)args[3]; // Do not replacedume the pingTargets or pingGraphs containers will have this key!
				IPAddress remoteHost = (IPAddress)args[4];
				Ping pinger = (Ping)args[5];
				pinger.PingCompleted -= pinger_PingCompleted;
				PingInstancePool.Recycle(pinger);
				if (e.Cancelled)
				{
					graph.AddPingLogToSpecificOffset(pingNum, new PingLog(time, 0, IPStatus.Unknown));
					Interlocked.Increment(ref failedPings);
					return;
				}
				graph.AddPingLogToSpecificOffset(pingNum, new PingLog(time, (short)e.Reply.RoundtripTime, e.Reply.Status));
				if (e.Reply.Status != IPStatus.Success)
				{
					Interlocked.Increment(ref failedPings);
					if (clearedDeadHosts && pingTargets.ContainsKey(pingTargetId))
						CreateLogEntry("" + GetTimestamp(time) + ", " + remoteHost.ToString() + ": " + e.Reply.Status.ToString());
				}
				else
				{
					if (!clearedDeadHosts)
					{
						pingTargetHasAtLeastOneSuccess[pingTargetId] = true;
					}
					Interlocked.Increment(ref successfulPings);
				}
			}
			finally
			{
				UpdatePingCounts(Interlocked.Read(ref successfulPings), Interlocked.Read(ref failedPings));
			}
		}

19 Source : MainForm.cs
with MIT License
from bp2008

private void controllerLoop(object arg)
		{
			currentIPAddress = null;
			object[] args = (object[])arg;
			string host = (string)args[0];
			bool traceRoute = (bool)args[1];
			bool reverseDnsLookup = (bool)args[2];
			bool preferIpv4 = (bool)args[3];

			foreach (PingGraphControl graph in pingGraphs.Values)
			{
				graph.ClearAll();
				RemoveEventHandlers(graph);
			}
			Interlocked.Exchange(ref successfulPings, 0);
			Interlocked.Exchange(ref failedPings, 0);
			pingGraphs.Clear();
			pingTargets.Clear();
			pingTargetHasAtLeastOneSuccess.Clear();
			clearedDeadHosts = false;
			panel_Graphs.Invoke((Action)(() =>
			{
				panel_Graphs.Controls.Clear();
			}));
			graphSortingCounter = 0;
			IPAddress target = null;
			try
			{
				string[] addresses = host.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				target = StringToIp(addresses[0], preferIpv4);
				currentIPAddress = target.ToString();
				CreateLogEntry("(" + GetTimestamp(DateTime.Now) + "): Initializing pings to " + host);

				// Multiple addresses
				if (addresses.Length > 1)
				{
					// Don't clear dead hosts from a predefined list
					clearedDeadHosts = true;
					foreach (string address in addresses)
					{
						IPAddress ip = StringToIp(address.Trim(), preferIpv4);
						string hostName = reverseDnsLookup ? GetIpHostname(ip) : "";
						AddPingTarget(ip, hostName);
					}
				}
				// Route
				else if (traceRoute)
				{
					CreateLogEntry("Tracing route ...");
					foreach (TracertEntry entry in Tracert.Trace(target, 64, 5000, reverseDnsLookup))
					{
						CreateLogEntry(entry.ToString());
						AddPingTarget(entry.Address, entry.Hostname);
					}
				}
				// Single address
				else
				{
					AddPingTarget(target, host);
				}

				CreateLogEntry("Now beginning pings");
				DateTime lastPingAt = DateTime.Now.AddSeconds(-60);
				byte[] buffer = new byte[0];

				long numberOfPingLoopIterations = 0;
				DateTime tenPingsAt = DateTime.MinValue;
				while (true)
				{
					try
					{
						if (!clearedDeadHosts && tenPingsAt != DateTime.MinValue && tenPingsAt.AddSeconds(10) < DateTime.Now)
						{
							if (pingTargets.Count > 1)
							{
								IList<int> pingTargetIds = pingTargets.Keys;
								foreach (int pingTargetId in pingTargetIds)
								{
									if (!pingTargetHasAtLeastOneSuccess[pingTargetId])
									{
										// This ping target has not yet had a successful response. replacedume it never will, and delete it.
										panel_Graphs.Invoke((Action)(() =>
										{
											pingTargets.Remove(pingTargetId);
											panel_Graphs.Controls.Remove(pingGraphs[pingTargetId]);
											RemoveEventHandlers(pingGraphs[pingTargetId]);
											pingGraphs.Remove(pingTargetId);
											if (pingGraphs.Count == 0)
											{
												Label lblNoGraphsRemain = new Label();
												lblNoGraphsRemain.Text = "All graphs were removed because" + Environment.NewLine + "none of the hosts responded to pings.";
												panel_Graphs.Controls.Add(lblNoGraphsRemain);
											}
											ResetGraphTimestamps();
										}));
									}
								}
								panel_Graphs.Invoke((Action)(() =>
								{
									panel_Graphs_Resize(null, null);
								}));
							}
							clearedDeadHosts = true;
						}
						while (pingDelay <= 0)
							Thread.Sleep(100);
						int msToWait = (int)(lastPingAt.AddMilliseconds(pingDelay) - DateTime.Now).TotalMilliseconds;
						while (msToWait > 0)
						{
							Thread.Sleep(Math.Min(msToWait, 1000));
							msToWait = (int)(lastPingAt.AddMilliseconds(pingDelay) - DateTime.Now).TotalMilliseconds;
						}
						lastPingAt = DateTime.Now;
						// We can't re-use the same Ping instance because it is only capable of one ping at a time.
						foreach (KeyValuePair<int, IPAddress> targetMapping in pingTargets)
						{
							PingGraphControl graph = pingGraphs[targetMapping.Key];
							long offset = graph.ClearNextOffset();
							Ping pinger = PingInstancePool.Get();
							pinger.PingCompleted += pinger_PingCompleted;
							pinger.SendAsync(targetMapping.Value, 5000, buffer, new object[] { lastPingAt, offset, graph, targetMapping.Key, targetMapping.Value, pinger });
						}
					}
					catch (ThreadAbortException ex)
					{
						throw ex;
					}
					catch (Exception)
					{
					}
					numberOfPingLoopIterations++;
					if (numberOfPingLoopIterations == 10)
						tenPingsAt = DateTime.Now;
				}
			}
			catch (ThreadAbortException)
			{
			}
			catch (Exception ex)
			{
				if (!(ex.InnerException is ThreadAbortException))
					MessageBox.Show(ex.ToString());
			}
			finally
			{
				CreateLogEntry("(" + GetTimestamp(DateTime.Now) + "): Shutting down pings to " + host);
				if (isRunning)
					btnStart_Click(btnStart, new EventArgs());
			}
		}

19 Source : TracertEntry.cs
with MIT License
from bp2008

public override string ToString()
		{
			string host;
			if (Address == null)
				host = "N/A";
			else if (string.IsNullOrEmpty(Hostname))
				host = Address.ToString();
			else
				host = Hostname + "[" + Address.ToString() + "]";
			string status;
			if (ReplyStatus == IPStatus.TimedOut)
				status = "Request Timed Out";
			else
				status = ReplyTime.ToString() + " ms";
			return HopID + " | " + host + " | " + status;
		}

19 Source : HexiController.cs
with MIT License
from breeswish

private async void HandleTcpClientConnectionAsync(TcpClient tcpClient, CancellationToken token)
        {
            Console.WriteLine("Remote connection from {0}", tcpClient.Client.RemoteEndPoint.ToString());

            HexiUdpClient client = new HexiUdpClient(((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address.MapToIPv4().ToString());

            ValueBag.HexiClientCount++;
            using (await ValueBag.HexiClientsLock.WriterLockAsync())
            {
                ValueBag.HexiClients.Add(client);
            }

            try
            {
                var bufferReqSize = new byte[4];
                byte[] bufferReqBody;
                byte[] bufferResSize;
                byte[] bufferResBody;
                NetworkStream networkStream = tcpClient.GetStream();

                while (true)
                {
                    // Read size
                    await networkStream.ReadAsync(bufferReqSize, 0, 4, token);
                    Int32 reqSize = BitConverter.ToInt32(bufferReqSize, 0);

                    // Read body
                    bufferReqBody = new byte[reqSize];
                    await networkStream.ReadAsync(bufferReqBody, 0, reqSize);
                    TcpRequestMessage request = TcpRequestMessage.Parser.ParseFrom(bufferReqBody);

                    bool responseSuccess = false;
                    switch (request.MsgType)
                    {
                        case TcpRequestMessage.Types.MsgType.Ping:
                            responseSuccess = true;
                            break;
                        case TcpRequestMessage.Types.MsgType.SetConfig:
                            client.SetTransmissionTarget(request.SetConfigBody.UdpPort, request.SetConfigBody.UdpToken);
                            responseSuccess = true;
                            break;
                        case TcpRequestMessage.Types.MsgType.TestConnection:
                            responseSuccess = true;
                            break;
                    }
                    
                    TcpResponseMessage response = new TcpResponseMessage
                    {
                        Success = responseSuccess,
                        TimeStamp = Utils.GetTimeStamp(DateTime.UtcNow),
                    };

                    // Write size and body
                    bufferResBody = response.ToByteArray();
                    bufferResSize = BitConverter.GetBytes(bufferResBody.Length);
                    await networkStream.WriteAsync(bufferResSize, 0, 4, token);
                    await networkStream.WriteAsync(bufferResBody, 0, bufferResBody.Length, token);
                }
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception)
            {
            }
            finally
            {
                if (tcpClient.Connected)
                {
                    tcpClient.Close();
                }
                client.Close();
                ValueBag.HexiClientCount--;
                using (await ValueBag.HexiClientsLock.WriterLockAsync())
                {
                    ValueBag.HexiClients.Remove(client);
                }
            }
        }

19 Source : SerializationUtils.cs
with MIT License
from BreezeHub

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			// convert an IPAddress object to a string representation of itself and Write it to the serialiser
			if (value.GetType() == typeof(IPAddress))
			{
				JToken.FromObject(value.ToString()).WriteTo(writer);
				return;
			}

			// convert a List<IPAddress> object to a string[] representation of itself and Write it to the serialiser
			if (value.GetType() == typeof(List<IPAddress>))
			{
				JToken.FromObject((from n in (List<IPAddress>)value select n.ToString()).ToList()).WriteTo(writer);
				return;
			}

			throw new NotImplementedException();
		}

19 Source : TorConnectionSettings.cs
with MIT License
from BreezeHub

internal TorClient CreateTorClient2()
		{
			if(string.IsNullOrEmpty(Preplacedword) && string.IsNullOrEmpty(CookieFile))
			{
				return new TorClient(Server.Address.ToString(), Server.Port);
			}
			if(!string.IsNullOrEmpty(Preplacedword))
			{
				return new TorClient(Server.Address.ToString(), Server.Port, Preplacedword);
			}
			if(!string.IsNullOrEmpty(CookieFile))
			{
				return new TorClient(Server.Address.ToString(), Server.Port, new FileInfo(CookieFile));
			}
			else
				throw new ConfigException("Invalid Tor configuration");
		}

19 Source : TumblerRuntime.cs
with MIT License
from BreezeHub

async Task ConfigureAsyncCore(TumblerConfiguration conf, ClientInteraction interaction)
		{
			Cooperative = conf.Cooperative;
			ClreplacedicTumblerParameters = conf.ClreplacedicTumblerParameters.Clone();
			Network = conf.Network;
			LocalEndpoint = conf.Listen;
			TumblerProtocol = conf.TumblerProtocol;
			
			bool torConfigured = false;
			if(conf.TorSettings != null)
			{
				Exception error = null;
				try
				{
					_Resources.Add(await conf.TorSettings.SetupAsync(interaction, conf.TorPath).ConfigureAwait(false));
					Logs.Configuration.LogInformation("Successfully authenticated to Tor");
					var torRSA = Path.Combine(conf.DataDir, "Tor.rsa");

					TorPrivateKey = null;
					if(File.Exists(torRSA))
						TorPrivateKey = File.ReadAllText(torRSA, Encoding.UTF8);

					TorConnection = conf.TorSettings.CreateTorClient2();
					_Resources.Add(TorConnection);

					await TorConnection.ConnectAsync().ConfigureAwait(false);
					await TorConnection.AuthenticateAsync().ConfigureAwait(false);
					var result = await TorConnection.RegisterHiddenServiceAsync(conf.Listen, conf.TorSettings.VirtualPort, TorPrivateKey).ConfigureAwait(false);
					if(TorPrivateKey == null)
					{
						File.WriteAllText(torRSA, result.PrivateKey, Encoding.UTF8);
						Logs.Configuration.LogWarning($"Tor RSA private key generated to {torRSA}");
					}

                    var tumblerUri = new TumblerUrlBuilder
                    {
	                    Host = result.HiddenServiceUri.Host,
						Port = result.HiddenServiceUri.Port
                    };
                    TumblerUris.Add(tumblerUri);
					TorUri = tumblerUri.GetRoutableUri(false);
					ClreplacedicTumblerParameters.ExpectedAddress = TorUri.AbsoluteUri;
					Logs.Configuration.LogInformation($"Tor configured on {result.HiddenServiceUri}");
					torConfigured = true;
				}
				catch(ConfigException ex)
				{
					error = ex;
				}
				catch(TorException ex)
				{
					error = ex;
				}
				catch(ClientInteractionException)
				{
				}
				if(error != null)
					Logs.Configuration.LogWarning("Error while configuring Tor hidden service: " + error.Message);
			}

			if (!torConfigured)
				Logs.Configuration.LogWarning("The tumbler is not configured as a Tor Hidden service");

			var tumlerKeyData = LoadRSAKeyData(conf.DataDir, "Tumbler.pem", conf.NoRSAProof);
			var voucherKeyData = LoadRSAKeyData(conf.DataDir, "Voucher.pem", conf.NoRSAProof);
			ClreplacedicTumblerParameters.ServerKey = tumlerKeyData.Item2;
			ClreplacedicTumblerParameters.VoucherKey = voucherKeyData.Item2;

			TumblerKey = tumlerKeyData.Item1;
			VoucherKey = voucherKeyData.Item1;

			if(!conf.TorMandatory)
			{
				// Construct a valid 16 character long onion address which will be used as a reference (it is not meant to be a valid IP address or hostname)
				string dummyOnionAddress = Environment.MachineName;
				if (dummyOnionAddress.Length < 16)
					dummyOnionAddress = dummyOnionAddress.PadRight(16, '-');

				TumblerUrlBuilder httpUri;

				//Set the Tor URI only if the Tor address has not been already set
				if (TorUri == null)
				{
					//Add onion style address, this is just a display address used when running MasterNode without Tor
					httpUri = new TumblerUrlBuilder()
					{
						Host = $"{dummyOnionAddress}.dummy",
						Port = conf.Listen.Port
					};
					TumblerUris.Add(httpUri);
					TorUri = httpUri.GetRoutableUri(false);

					//Add IP address of the network card with Internet connection
					httpUri = new TumblerUrlBuilder()
					{
						Host = LocalEndpoint.Address.ToString(),
						Port = LocalEndpoint.Port
					};
					TumblerUris.Add(httpUri);

					if (String.IsNullOrEmpty(ClreplacedicTumblerParameters.ExpectedAddress))
						ClreplacedicTumblerParameters.ExpectedAddress = httpUri.GetRoutableUri(false).AbsoluteUri;
				}
				else
				{
					if (String.IsNullOrEmpty(ClreplacedicTumblerParameters.ExpectedAddress))
						ClreplacedicTumblerParameters.ExpectedAddress = TorUri.AbsoluteUri;
				}
			}
			ClreplacedicTumblerParametersHash = ClreplacedicTumblerParameters.GetHash();
			var configurationHash = ClreplacedicTumblerParameters.GetHash();
			foreach(var uri in TumblerUris)
			{
				uri.ConfigurationHash = configurationHash;
			}

			Logs.Configuration.LogInformation("");
			Logs.Configuration.LogInformation($"--------------------------------");
			Logs.Configuration.LogInformation($"Shareable URIs of the running tumbler are:");
			foreach(var uri in TumblerUris)
			{
				Logs.Configuration.LogInformation(uri.ToString());
			}
			Logs.Configuration.LogInformation($"--------------------------------");
			Logs.Configuration.LogInformation("");
			
			Repository = conf.DBreezeRepository;
			_Resources.Add(Repository);
			Tracker = conf.Tracker;
			Services = conf.Services;
		}

19 Source : Cast.cs
with GNU General Public License v3.0
from BRH-Media

private static string GetLocalIpAddress()
        {
            //current DNS Host (this PC)
            var host = Dns.GetHostEntry(Dns.GetHostName());

            //go through each address on the current machine
            foreach (var ip in host.AddressList)

                //check if it's IPv4 and if it's a private address (e.g. 10.* and 192.168.*)
                if (ip.AddressFamily == AddressFamily.InterNetwork && Methods.IsPrivateIp(ip.ToString()))

                    //first match is returned
                    return ip.ToString();

            //return blank for no matches
            return @"";
        }

19 Source : PhilipsHueServices.cs
with MIT License
from brminnick

static IPhilipsHueBridgeApi InitializePhilipsHueBridgeApiClient(IPAddress bridgeIPAddress) => InitializePhilipsHueBridgeApiClient($"http://{bridgeIPAddress.ToString()}");

19 Source : DotNettyClientFactory.cs
with MIT License
from brucehu123

private IRpcClient GetOrAdd(EndPoint endPoint)
        {
            try
            {
                return _clients.GetOrAdd(endPoint, ep =>
                {
                    return new Lazy<IRpcClient>(() =>
                    {
                        var clientService = new DotNettyClientService();
                        var bootstrap = _bootstrap;
                        var channel = bootstrap.ConnectAsync(ep).Result;
                        channel.GetAttribute(origEndPointKey).Set(ep);
                        channel.GetAttribute(_clientServiceAttributeKey).Set(clientService);
                        return new DotNettyClient(channel, clientService);
                    });
                }).Value;
            }
            catch (Exception e)
            {
                _clients.TryRemove(endPoint, out var value);
                var ipEndPoint = endPoint as IPEndPoint;
                if (ipEndPoint != null)
                    _healthCheckService.MarkFailure(new IpAddressModel(ipEndPoint.Address.ToString(), ipEndPoint.Port));
                throw new RpcConnectedException("与服务端连接时发生异常。", e);
            }
        }

See More Examples