Пример #1
0
        public static IObservable <NameResolutionResult> ResolveHostName(DnsEndPoint endPoint, NetworkInterfaceInfo networkInterface)
        {
            Contract.Requires(endPoint != null);
            Contract.Requires(networkInterface != null);
            Contract.Ensures(Contract.Result <IObservable <NameResolutionResult> >() != null);

            var subject = new AsyncSubject <NameResolutionResult>();

            try
            {
                DeviceNetworkInformation.ResolveHostNameAsync(
                    endPoint,
                    networkInterface,
                    result =>
                {
                    var s = (AsyncSubject <NameResolutionResult>)result.AsyncState;

                    s.OnNext(result);
                    s.OnCompleted();
                },
                    subject);
            }
            catch (Exception ex)
            {
                subject.OnError(ex);
            }

            return(subject.AsObservable());
        }
Пример #2
0
        public override Task <bool> IsHostReachable(string host)
        {
            var tcs = new TaskCompletionSource <bool>();

            DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint(host, 80), x => tcs.SetResult(x.HostName != null), null);
            return(tcs.Task);
        }
Пример #3
0
 public void getConnectionInfo(string empty)
 {
     // Use the GetIsNetworkAvailable method to quickly determine if we have a connection or not
     // Otherwise, resolving a DNS name with no connection takes a while.
     if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
     {
         // We have to try to resolve a host name to get the specific subtype of network available.
         // Kind of a shitty API here MSFT
         DeviceNetworkInformation.ResolveHostNameAsync(
             new DnsEndPoint("microsoft.com", 80),
             new NameResolutionCallback(nrr =>
         {
             if (nrr.NetworkErrorCode == NetworkError.Success)
             {
                 updateConnectionType(checkConnectionType(nrr.NetworkInterface.InterfaceSubtype));
             }
             else
             {
                 updateConnectionType(NONE);
             }
         }
                                        ),
             null
             );
     }
     else
     {
         updateConnectionType(NONE);
     }
 }
        /// <summary>
        /// Tests if a host name is pingable
        /// </summary>
        /// <param name="host">The host name can either be a machine name, such as "java.sun.com", or a textual representation of its IP address (127.0.0.1)</param>
        /// <param name="msTimeout">Timeout in milliseconds</param>
        /// <returns></returns>
        public override async Task <bool> IsReachable(string host, int msTimeout = 5000)
        {
            if (string.IsNullOrEmpty(host))
            {
                throw new ArgumentNullException("host");
            }

            if (!IsConnected)
            {
                return(false);
            }

            return(await Task.Run(() =>
            {
                var manualResetEvent = new ManualResetEvent(false);
                var reachable = false;
                DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint(host, 80), result =>
                {
                    reachable = result.NetworkInterface != null;
                    manualResetEvent.Set();
                }, null);
                manualResetEvent.WaitOne(TimeSpan.FromMilliseconds(msTimeout));
                return reachable;
            }));
        }
Пример #5
0
        /// <summary>
        /// Method to check internet connection to the host
        /// </summary>
        /// <returns></returns>
        public static bool CheckNetwork()
        {
            var  manualResetEvent            = new ManualResetEvent(false);
            bool internetConnectionAvailable = true;

            DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint("smartfiction.ru", 80),
                                                          networkInfo =>
            {
                if (networkInfo.NetworkInterface == null)
                {
                    internetConnectionAvailable = false;
                }
                manualResetEvent.Set();
            }, null);
            manualResetEvent.WaitOne(TimeSpan.FromMilliseconds(50));
            if (!internetConnectionAvailable)
            {
                System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    MessageBox.Show(
                        "Так уж вышло, что для некоторых действий требуется интернет! В данный момент программа не может соединиться с smartfiction.ru",
                        "Warning", MessageBoxButton.OK);

                    //one can use here new Game().Exit()
                    //throw new Exception(
                    //    "ExitApplicationException");
                });

                return(false);
            }
            return(true);
        }
Пример #6
0
 public MainPage()
 {
     this.InitializeComponent();
     this._feContainer = this.LayoutRoot;
     if (!DeviceNetworkInformation.get_IsNetworkAvailable())
     {
         MessageBox.Show("Vui lòng kết nối 3g hoặc wifi");
         Application.get_Current().Terminate();
     }
     else
     {
         this.LoadQc();
     }
     this._lsSaveFav = tiviViet.App.ListFavorite;
     this.FeedbackOverlay.VisibilityChanged += new EventHandler(this, tiviViet.MainPage.FeedbackOverlay_VisibilityChanged);
     if (!IsolatedStorageSettings.get_ApplicationSettings().Contains("Zipcodes"))
     {
         this.CreateTiles();
     }
     if (!tiviViet.App.sttRemove)
     {
         this.ShowVideo();
         this.btnRemove.set_Visibility(0);
     }
     Deployment.get_Current().get_Dispatcher().BeginInvoke(new Action(this, () => {
         this.LoadData();
         GetData.CheckAppVersion();
     }));
 }
Пример #7
0
        public static Task <bool> check_internet_connection_hard()
        {
            //Thread.Sleep(10000);//في المين ثريد
            if (DeviceNetworkInformation.IsNetworkAvailable == false)
            {
                return(Task.FromResult(false));
            }

            return(Task.Run(() =>
            {
                //Thread.Sleep(3000);//في الثريد
                var manualResetEvent = new ManualResetEvent(false);
                var reachable = false;
                DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint("www.google.com", 80), result =>
                {
                    //Thread.Sleep(10000);//في الثريد
                    reachable = result.NetworkInterface != null;
                    manualResetEvent.Set();
                }, null);

                manualResetEvent.WaitOne(TimeSpan.FromMilliseconds(10000));
                //Thread.Sleep(10000); //في الثريد
                return reachable;
            }));
        }
Пример #8
0
        private void ConnectButton_Click(object sender, EventArgs e)
        {
            string      server   = "sandstorm.case.edu";
            DnsEndPoint endpoint = new DnsEndPoint(server, 0);

            DeviceNetworkInformation.ResolveHostNameAsync(endpoint, OnNameResolved, null);
        }
Пример #9
0
        public Task <bool> IsReachable(string host, TimeSpan timeout)
        {
            return(Task <bool> .Run(() =>
            {
                if (!DeviceNetworkInformation.IsNetworkAvailable)
                {
                    return false;
                }

                AutoResetEvent e = new AutoResetEvent(false);

                bool isReachable = false;
                NameResolutionCallback d = delegate(NameResolutionResult result)
                {
                    isReachable = result.NetworkErrorCode == NetworkError.Success;
                    e.Set();
                };

                DeviceNetworkInformation.ResolveHostNameAsync(new System.Net.DnsEndPoint(host, 0), d, this);


                e.WaitOne(timeout);

                return isReachable;
            }));
        }
Пример #10
0
        /// <summary>
        /// Returns the Internet Protocol (IP) addresses for the specified host.
        /// </summary>
        /// <param name="hostNameOrAddress">The host name or IP address to resolve</param>
        /// <returns>
        /// An array of type <see cref="IPAddress"/> that holds the IP addresses for the host that
        /// is specified by the <paramref name="hostNameOrAddress"/> parameter.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="hostNameOrAddress"/> is <c>null</c>.</exception>
        /// <exception cref="SocketException">An error is encountered when resolving <paramref name="hostNameOrAddress"/>.</exception>
        public static IPAddress[] GetHostAddresses(string hostNameOrAddress)
        {
#if FEATURE_DNS_SYNC
            return(Dns.GetHostAddresses(hostNameOrAddress));
#elif FEATURE_DNS_TAP
            return(Dns.GetHostAddressesAsync(hostNameOrAddress).Result);
#else
            IPAddress address;
            if (IPAddress.TryParse(hostNameOrAddress, out address))
            {
                return new [] { address }
            }
            ;

#if FEATURE_DEVICEINFORMATION_APM
            var resolveCompleted = new ManualResetEvent(false);
            NameResolutionResult nameResolutionResult = null;
            DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint(hostNameOrAddress, 0), result =>
            {
                nameResolutionResult = result;
                resolveCompleted.Set();
            }, null);

            // wait until address is resolved
            resolveCompleted.WaitOne();

            if (nameResolutionResult.NetworkErrorCode == NetworkError.Success)
            {
                var addresses = new List <IPAddress>(nameResolutionResult.IPEndPoints.Select(p => p.Address).Distinct());

                return(addresses.ToArray());
            }
            throw new SocketException((int)nameResolutionResult.NetworkErrorCode);
#elif FEATURE_DATAGRAMSOCKET
            // TODO we may need to only return those IP addresses that are supported on the current system
            // TODO http://wojciechkulik.pl/csharp/winrt-how-to-detect-supported-ip-versions

            var endpointPairs = DatagramSocket.GetEndpointPairsAsync(new HostName(hostNameOrAddress), "").GetAwaiter().GetResult();
            var addresses     = new List <IPAddress>();
            foreach (var endpointPair in endpointPairs)
            {
                if (endpointPair.RemoteHostName.Type == HostNameType.Ipv4 || endpointPair.RemoteHostName.Type == HostNameType.Ipv6)
                {
                    addresses.Add(IPAddress.Parse(endpointPair.RemoteHostName.CanonicalName));
                }
            }
            if (addresses.Count == 0)
            {
                throw new SocketException((int)System.Net.Sockets.SocketError.HostNotFound);
            }
            return(addresses.ToArray());
#else
            throw new NotSupportedException("Resolving hostname to IP address is not implemented.");
#endif // FEATURE_DEVICEINFORMATION_APM
#endif
        }
    }
Пример #11
0
        private void btnHostResolve_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            txIP.Text = "";

            if (RscUtils.IsIpAddress(txHostName.Text))
            {
                txIP.Text = "ERR: IP can not be resolved!";
            }
            else
            {
                var endpoint = new DnsEndPoint(txHostName.Text, 0);
                DeviceNetworkInformation.ResolveHostNameAsync(endpoint, OnHostResolved, null);
            }
        }
Пример #12
0
        /// <summary>
        /// Synchronously resolves hostnames
        /// </summary>
        public static NameResolutionResult ResolveHostname(DnsEndPoint endpoint)
        {
            AutoResetEvent       signal = new AutoResetEvent(false);
            NameResolutionResult nameResolutionResult = null;

            DeviceNetworkInformation.ResolveHostNameAsync(endpoint, (result) =>
            {
                nameResolutionResult = result;
                signal.Set();
            }, null);

            signal.WaitOne();
            return(nameResolutionResult);
        }
 public async void send()
 {
     DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint(uri.Host, 0), OnNameResolved, null);
 }
Пример #14
0
        public static void GetNetName()
        {
            DeviceNetworkInformation.ResolveHostNameAsync(
                new DnsEndPoint("www.microsoft.com", 80),
                new NameResolutionCallback(handle =>
            {
                string Name               = "";
                string NetName            = "";
                NetworkInterfaceInfo info = handle.NetworkInterface;
                if (info != null)
                {
                    Name = info.InterfaceName + " " + info.Description + " ";

                    switch (info.InterfaceType)
                    {
                    case NetworkInterfaceType.Ethernet:
                        NetName = "Ethernet";
                        break;

                    case NetworkInterfaceType.MobileBroadbandCdma:
                    case NetworkInterfaceType.MobileBroadbandGsm:
                        switch (info.InterfaceSubtype)
                        {
                        case NetworkInterfaceSubType.Cellular_3G:
                            //NetName = "Cellular_3G + 3G";
                            NetName = "3G";
                            break;

                        case NetworkInterfaceSubType.Cellular_EVDO:
                            //NetName = "Cellular_EVDO + 3G";
                            NetName = "3G";
                            break;

                        case NetworkInterfaceSubType.Cellular_EVDV:
                            //NetName = "Cellular_EVDV + 3G";
                            NetName = "3G";
                            break;

                        case NetworkInterfaceSubType.Cellular_HSPA:
                            NetName = "3G";
                            //NetName = "Cellular_HSPA + 3G";
                            break;

                        case NetworkInterfaceSubType.Cellular_GPRS:
                            //NetName = "Cellular_GPRS + 2G";
                            NetName = "2G";
                            break;

                        case NetworkInterfaceSubType.Cellular_EDGE:
                            NetName = "2G";
                            // NetName = "Cellular_EDGE + 2G";
                            break;

                        case NetworkInterfaceSubType.Cellular_1XRTT:
                            //NetName = "Cellular_1XRTT + 2G";
                            NetName = "2G";
                            break;

                        default:
                            NetName = "None";
                            break;
                        }
                        break;

                    case NetworkInterfaceType.Wireless80211:
                        NetName = "WiFi";
                        break;

                    default:
                        NetName = "None";
                        break;
                    }
                }
                else
                {
                    NetName = "None";
                }

                CommonData.NetworkStatus = NetName;
                string tip = "";
                if (NetName == "None")
                {
                    tip = AppResources.NoneNetwork;
                }
                else
                {
                    tip = AppResources.ShowNetwork.Replace("#name#", NetName);
                }

                if (NetName != "WiFi")
                {
                    App.DownVideoModel.StopGetVideoData();
                }
                else
                {
                    App.DownVideoModel.CheckLocalData();
                }

                ShowToast(tip);
            }), null);
        }
Пример #15
0
        public void DnsLookup(string hostname, int port)
        {
            var endpoint = new DnsEndPoint(hostname, port, System.Net.Sockets.AddressFamily.InterNetwork);

            DeviceNetworkInformation.ResolveHostNameAsync(endpoint, OnNameResolved, null);
        }
        private void OnOK()
        {
            bool bGoBack = true;

            if (!DeviceNetworkInformation.IsNetworkAvailable)
            {
                ConnectionSettingsTask connectionSettingsTask = new ConnectionSettingsTask();
                connectionSettingsTask.ConnectionSettingsType = ConnectionSettingsType.WiFi;
                connectionSettingsTask.Show();

                return;
            }

            if (m_AppInput != null)
            {
                string strRes = txSvrIP.Text;

                //NoEmpty...
                if (m_AppInput.GetFlag(1).Length > 0)
                {
                    strRes = strRes.Trim();

                    if (strRes.Length == 0)
                    {
                        MessageBox.Show("Value must not be empty!");
                        return;
                    }
                }

                /*
                 * //FileName...
                 * if( m_AppInput.GetFlag(1).Length > 0 )
                 * {
                 *      strRes = strRes.Trim();
                 *
                 *      string strChk = "\\/:*?\"<>|";
                 *      foreach( char cChk in strChk )
                 *      {
                 *              if( strRes.IndexOf( cChk ) >= 0 )
                 *              {
                 *                      MessageBox.Show("Value must not contain characters of '" + strChk + "'!");
                 *                      return;
                 *              }
                 *      }
                 * }
                 */

                bGoBack = false;

                if (RscUtils.IsIpAddress(strRes))
                {
                    /*
                     * MessageBox.Show("IP Address is not allowed here!");
                     * return;
                     */

                    DoOk();
                }
                else
                {
                    prsBar.Visibility = Rsc.Visible;

                    var endpoint = new DnsEndPoint(strRes, 0);
                    DeviceNetworkInformation.ResolveHostNameAsync(endpoint, OnHostResolved, null);
                }
            }

            if (bGoBack)
            {
                this.NavigationService.GoBack();
            }
        }
Пример #17
0
        public static Socket ConnectToSocks5Proxy(Socket s, string proxyAdress, ushort proxyPort, string destAddress, ushort destPort, string userName, string password)
        {
            IPAddress destIP   = null;
            IPAddress proxyIP  = null;
            var       request  = new byte[256];
            var       response = new byte[256];
            ushort    nIndex;

            try
            {
                proxyIP = IPAddress.Parse(proxyAdress);
            }
            catch (FormatException)
            {    // get the IP address
                NameResolutionResult resolutionResult = null;
                var dnsResolveEvent = new AutoResetEvent(false);
                var endpoint        = new DnsEndPoint(proxyAdress, 0);
                DeviceNetworkInformation.ResolveHostNameAsync(endpoint, result =>
                {
                    resolutionResult = result;
                    dnsResolveEvent.Set();
                }, null);
                dnsResolveEvent.WaitOne();
                proxyIP = resolutionResult.IPEndPoints[0].Address;
            }

            // Parse destAddress (assume it in string dotted format "212.116.65.112" )
            try
            {
                destIP = IPAddress.Parse(destAddress);
            }
            catch (FormatException)
            {
                // wrong assumption its in domain name format "www.microsoft.com"
            }

            var proxyEndPoint = new IPEndPoint(proxyIP, proxyPort);

            // open a TCP connection to SOCKS server...
            var connected = Connect(s, proxyEndPoint);

            if (!connected)
            {
                throw new ConnectionException("Can't connect to proxy server.");
            }

            nIndex            = 0;
            request[nIndex++] = 0x05; // Version 5.
            request[nIndex++] = 0x02; // 2 Authentication methods are in packet...
            request[nIndex++] = 0x00; // NO AUTHENTICATION REQUIRED
            request[nIndex++] = 0x02; // USERNAME/PASSWORD

            Send(s, request, 0, nIndex);
            var nGot = Receive(s, response, 0, response.Length);

            // Receive 2 byte response...
            if (nGot != 2)
            {
                throw new ConnectionException("Bad response received from proxy server.");
            }

            if (response[1] == 0xFF)
            {    // No authentication method was accepted close the socket.
                s.Close();
                throw new ConnectionException("None of the authentication method was accepted by proxy server.");
            }

            byte[] rawBytes;
            //Username/Password Authentication protocol
            if (response[1] == 0x02)
            {
                nIndex            = 0;
                request[nIndex++] = 0x01; // Version 5.

                // add user name
                request[nIndex++] = (byte)userName.Length;
                rawBytes          = Encoding.UTF8.GetBytes(userName);
                rawBytes.CopyTo(request, nIndex);
                nIndex += (ushort)rawBytes.Length;

                // add password
                request[nIndex++] = (byte)password.Length;
                rawBytes          = Encoding.UTF8.GetBytes(password);
                rawBytes.CopyTo(request, nIndex);
                nIndex += (ushort)rawBytes.Length;

                // Send the Username/Password request
                Send(s, request, 0, nIndex);
                nGot = Receive(s, response, 0, response.Length);

                if (nGot != 2)
                {
                    throw new ConnectionException("Bad response received from proxy server.");
                }
                if (response[1] != 0x00)
                {
                    throw new ConnectionException("Bad Usernaem/Password.");
                }
            }
            //// This version only supports connect command.
            //// UDP and Bind are not supported.

            // Send connect request now...
            nIndex            = 0;
            request[nIndex++] = 0x05;    // version 5.
            request[nIndex++] = 0x01;    // command = connect.
            request[nIndex++] = 0x00;    // Reserve = must be 0x00

            if (destIP != null)
            {
                // Destination adress in an IP.
                switch (destIP.AddressFamily)
                {
                case AddressFamily.InterNetwork:
                    // Address is IPV4 format
                    request[nIndex++] = 0x01;
                    rawBytes          = destIP.GetAddressBytes();
                    rawBytes.CopyTo(request, nIndex);
                    nIndex += (ushort)rawBytes.Length;
                    break;

                case AddressFamily.InterNetworkV6:
                    // Address is IPV6 format
                    request[nIndex++] = 0x04;
                    rawBytes          = destIP.GetAddressBytes();
                    rawBytes.CopyTo(request, nIndex);
                    nIndex += (ushort)rawBytes.Length;
                    break;
                }
            }
            else
            {
                // Dest. address is domain name.
                request[nIndex++] = 0x03;                               // Address is full-qualified domain name.
                request[nIndex++] = Convert.ToByte(destAddress.Length); // length of address.
                rawBytes          = Encoding.UTF8.GetBytes(destAddress);
                rawBytes.CopyTo(request, nIndex);
                nIndex += (ushort)rawBytes.Length;
            }

            // using big-edian byte order
            byte[] portBytes = BitConverter.GetBytes(destPort);
            for (int i = portBytes.Length - 1; i >= 0; i--)
            {
                request[nIndex++] = portBytes[i];
            }

            // send connect request.
            Send(s, request, 0, nIndex);
            nGot = Receive(s, response, 0, response.Length);

            if (response[1] != 0x00)
            {
                throw new ConnectionException(errorMsgs[response[1]]);
            }
            // Success Connected...
            return(s);
        }
Пример #18
0
        /// <summary>
        /// Gets the MEGA DNS servers IP addresses.
        /// </summary>
        /// <param name="refresh">Indicates if should refresh the previously stored addresses.</param>
        /// <returns>String with the MEGA DNS servers IP addresses separated by commas.</returns>
        public static string GetMegaDnsServers(bool refresh = true)
        {
            if (!refresh && !string.IsNullOrWhiteSpace(MegaDnsServers))
            {
                return(MegaDnsServers);
            }

            try
            {
                if (!IsNetworkAvailable())
                {
                    return(null);
                }

                LogService.Log(MLogLevel.LOG_LEVEL_INFO, "Getting MEGA DNS servers...");
                var endpoint = new DnsEndPoint("ns.mega.co.nz", 0);

                var autoResetEvent = new AutoResetEvent(false);
                DeviceNetworkInformation.ResolveHostNameAsync(endpoint,
                                                              (NameResolutionResult result) =>
                {
                    string dnsServers = string.Empty;
                    try
                    {
                        if (result.IPEndPoints != null)
                        {
                            IPEndPoint[] endpoints = result.IPEndPoints;
                            foreach (IPEndPoint address in endpoints)
                            {
                                if (dnsServers.Length > 0)
                                {
                                    dnsServers = string.Concat(dnsServers, ",");
                                }

                                dnsServers = string.Concat(dnsServers, address.Address.ToString());
                            }
                        }

                        if (string.IsNullOrWhiteSpace(dnsServers))
                        {
                            LogService.Log(MLogLevel.LOG_LEVEL_WARNING, "No MEGA DNS servers.");
                            autoResetEvent.Set();
                            return;
                        }

                        LogService.Log(MLogLevel.LOG_LEVEL_INFO, "MEGA DNS servers: " + dnsServers);
                        MegaDnsServers = dnsServers;
                    }
                    catch (Exception e)
                    {
                        LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Error getting MEGA DNS servers.", e);
                    }
                    finally
                    {
                        autoResetEvent.Set();
                    }
                },
                                                              null);

                autoResetEvent.WaitOne();

                return(MegaDnsServers);
            }
            catch (Exception e)
            {
                LogService.Log(MLogLevel.LOG_LEVEL_ERROR, "Error getting MEGA DNS servers.", e);
                return(null);
            }
        }
    public void DnsLookupAsync(string hostname)
    {
        var endpoint = new DnsEndPoint(hostname, 0);

        DeviceNetworkInformation.ResolveHostNameAsync(endpoint, OnNameResolved, null);
    }