Obtenir une adresse IP publique / externe?
je ne peux pas sembler obtenir ou de trouver des informations sur la recherche de mes routeurs IP publique? Est-ce parce que cela ne peut pas être fait de cette façon et devrait l'obtenir d'un site web?
24 réponses
de C#, vous pouvez utiliser les bibliothèques de client web pour récupérer whatismyip
static void Main(string[] args)
{
HTTPGet req = new HTTPGet();
req.Request("http://checkip.dyndns.org");
string[] a = req.ResponseBody.Split(':');
string a2 = a[1].Substring(1);
string[] a3=a2.Split('<');
string a4 = a3[0];
Console.WriteLine(a4);
Console.ReadLine();
}
Faire ce petit truc avec Check IP DNS
Utiliser HTTPGet classe que j'ai trouvé sur Goldb-Httpget C#
utilisant C#, avec webclient est un court.
public static void Main(string[] args)
{
string externalip = new WebClient().DownloadString("http://icanhazip.com");
Console.WriteLine(externalip);
}
Ligne de Commande (fonctionne sur Linux et Windows)
wget -qO- http://bot.whatismyipaddress.com
ou
curl http://ipinfo.io/ip
With .Net WebRequest:
public static string GetPublicIP()
{
string url = "http://checkip.dyndns.org";
System.Net.WebRequest req = System.Net.WebRequest.Create(url);
System.Net.WebResponse resp = req.GetResponse();
System.IO.StreamReader sr = new System.IO.StreamReader(resp.GetResponseStream());
string response = sr.ReadToEnd().Trim();
string[] a = response.Split(':');
string a2 = a[1].Substring(1);
string[] a3 = a2.Split('<');
string a4 = a3[0];
return a4;
}
string pubIp = new System.Net.WebClient().DownloadString("https://api.ipify.org");
service Similaire
private string GetPublicIpAddress()
{
var request = (HttpWebRequest)WebRequest.Create("http://ifconfig.me");
request.UserAgent = "curl"; // this simulate curl linux command
string publicIPAddress;
request.Method = "GET";
using (WebResponse response = request.GetResponse())
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
publicIPAddress = reader.ReadToEnd();
}
}
return publicIPAddress.Replace("\n", "");
}
en théorie, votre routeur devrait être en mesure de vous indiquer l'adresse IP publique du réseau, mais la façon de le faire sera nécessairement incohérente/Non simple, si même possible avec certains périphériques de routeur.
la méthode la plus simple et la plus fiable est d'envoyer une demande à une page Web qui retourne votre adresse IP comme le serveur le voit. Dyndns.org fournit un bon service pour cela:
Ce qui est retourné est extrêmement simple, court document HTML, contenant le texte Current IP Address: 157.221.82.39 (fausse adresse IP), ce qui est trivial de l'extrait de la réponse HTTP.
moyen Rapide pour obtenir l'adresse ip Externe sans aucune connexion Actuellement aucun besoin d'aucune connexion Http pour que
vous devez d'abord ajouter NATUPNPLib.dll sur la référence Et le sélectionner à partir des références et de vérifier à partir de la fenêtre des propriétés Type D'Interop intégré à False
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NATUPNPLib; // Add this dll from referance and chande Embed Interop Interop to false from properties panel on visual studio
using System.Net;
namespace Client
{
class NATTRAVERSAL
{
//This is code for get external ip
private void NAT_TRAVERSAL_ACT()
{
UPnPNATClass uPnP = new UPnPNATClass();
IStaticPortMappingCollection map = uPnP.StaticPortMappingCollection;
foreach (IStaticPortMapping item in map)
{
Debug.Print(item.ExternalIPAddress); //This line will give you external ip as string
break;
}
}
}
}
développant sur ce réponse par @ suneel ranga :
static System.Net.IPAddress GetPublicIp(string serviceUrl = "https://ipinfo.io/ip")
{
return System.Net.IPAddress.Parse(new System.Net.WebClient().DownloadString(serviceUrl));
}
où vous utiliseriez un service avec System.Net.WebClient qui montre simplement l'adresse IP comme une chaîne de caractères et utilise l'objet System.Net.IPAddress . Voici quelques-uns de ces services*:
- https://ipinfo.io/ip /
- https://api.ipify.org /
- https://icanhazip.com /
- http://checkip.amazonaws.com / (no SSL)
- https://wtfismyip.com/text
- https://myip.dnsdynamic.com / (bien que l'identité ne soit pas fiable et que le cryptage soit obsolète)
* certains services ont été mentionnés dans cette question et de ces réponses de superuser site .
Avec quelques lignes de code, vous pouvez écrire votre propre Serveur Http pour cela.
HttpListener listener = new HttpListener();
listener.Prefixes.Add("http://+/PublicIP/");
listener.Start();
while (true)
{
HttpListenerContext context = listener.GetContext();
string clientIP = context.Request.RemoteEndPoint.Address.ToString();
using (Stream response = context.Response.OutputStream)
using (StreamWriter writer = new StreamWriter(response))
writer.Write(clientIP);
context.Response.Close();
}
alors chaque fois que vous avez besoin de connaître votre ip publique, vous pouvez le faire.
WebClient client = new WebClient();
string ip = client.DownloadString("http://serverIp/PublicIP");
checkip.dyndns.org ne fonctionne pas toujours correctement. Par exemple, pour ma machine, il affiche l'adresse après-NAT interne:
Current IP Address: 192.168.1.120
je pense que cela se passe, parce que j'ai ma zone DNS locale derrière NAT, et mon navigateur envoie à checip son adresse IP locale, qui est retournée.
aussi, http est un protocole TCP lourd et orienté texte, donc pas très adapté pour une demande régulière rapide et efficace pour IP externe adresse. Je suggère d'utiliser UDP-basé, STUN binaire, spécialement conçu à cet effet:
http://en.wikipedia.org/wiki/STUN
STUN-server est comme "UDP mirror". Tu regardes, et tu vois "à quoi je ressemble".
il y a de nombreux serveurs publics dans le monde, où vous pouvez demander votre IP externe. Par exemple, voir ici:
http://www.voip-info.org/wiki/view/STUN
vous pouvez télécharger n'importe quelle bibliothèque stun-client, à partir D'Internet, par exemple, ici:
http://www.codeproject.com/Articles/18492/STUN-Client
et utilisez-le.
je le fais en utilisant HttpClient de System.Net.Http :
public static string PublicIPAddress()
{
string uri = "http://checkip.dyndns.org/";
string ip = String.Empty;
using (var client = new HttpClient())
{
var result = client.GetAsync(uri).Result.Content.ReadAsStringAsync().Result;
ip = result.Split(':')[1].Split('<')[0];
}
return ip;
}
public static string GetPublicIP()
{
return new System.Net.WebClient().DownloadString("https://ipinfo.io/ip").Replace("\n","");
}
quand je debug, j'utilise la suite pour construire l'URL extérieurement appelable, mais vous pouvez juste utiliser les 2 premières lignes pour obtenir votre IP publique:
public static string ExternalAction(this UrlHelper helper, string actionName, string controllerName = null, RouteValueDictionary routeValues = null, string protocol = null)
{
#if DEBUG
var client = new HttpClient();
var ipAddress = client.GetStringAsync("http://ipecho.net/plain").Result;
// above 2 lines should do it..
var route = UrlHelper.GenerateUrl(null, actionName, controllerName, routeValues, helper.RouteCollection, helper.RequestContext, true);
if (route == null)
{
return route;
}
if (string.IsNullOrEmpty(protocol) && string.IsNullOrEmpty(ipAddress))
{
return route;
}
var url = HttpContext.Current.Request.Url;
protocol = !string.IsNullOrWhiteSpace(protocol) ? protocol : Uri.UriSchemeHttp;
return string.Concat(protocol, Uri.SchemeDelimiter, ipAddress, route);
#else
helper.Action(action, null, null, HttpContext.Current.Request.Url.Scheme)
#endif
}
j'ai trouvé que http://checkip.dyndns.org / me donnait des balises html que j'ai dû traiter mais https://icanhazip.com / était juste en train de me donner une simple ficelle. Malheureusement https://icanhazip.com / me donne l'adresse ip6 et j'avais besoin d'ip4. Heureusement il y a 2 sous-domaines que vous pouvez choisir, ipv4.icanhazip.com et ipv6.icanhazip.com.
string externalip = new WebClient().DownloadString("https://ipv4.icanhazip.com/");
Console.WriteLine(externalip);
Console.WriteLine(externalip.TrimEnd());
meilleure réponse j'ai trouvé
pour obtenir l'adresse IP distante le plus rapidement possible. Vous devez utiliser un downloader, ou créer un serveur sur votre ordinateur.
les inconvénients de l'utilisation de ce code simple: (qui est recommandé) est qu'il faudra 3-5 secondes pour obtenir votre adresse IP à distance parce que le WebClient une fois initialisé prend toujours 3-5 secondes pour vérifier les paramètres de votre proxy.
public static string GetIP()
{
string externalIP = "";
externalIP = new WebClient().DownloadString("http://checkip.dyndns.org/");
externalIP = (new Regex(@"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"))
.Matches(externalIP)[0].ToString();
return externalIP;
}
Voici comment je l'ai réparé.. (la première fois prend encore 3-5 secondes) mais après cela il obtiendra toujours votre adresse IP distante dans 0-2 secondes selon votre connexion.
public static WebClient webclient = new WebClient();
public static string GetIP()
{
string externalIP = "";
externalIP = webclient.DownloadString("http://checkip.dyndns.org/");
externalIP = (new Regex(@"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"))
.Matches(externalIP)[0].ToString();
return externalIP;
}
la plupart des réponses mentionnent http://checkip.dyndns.org en solution. Pour nous, il n'a pas bien fonctionné. Nous avons fait face à des temps morts beaucoup de temps. C'est vraiment troublant si votre programme dépend de la détection D'IP.
comme solution, nous utilisons la méthode suivante dans l'une de nos applications bureautiques:
// Returns external/public ip
protected string GetExternalIP()
{
try
{
using (MyWebClient client = new MyWebClient())
{
client.Headers["User-Agent"] =
"Mozilla/4.0 (Compatible; Windows NT 5.1; MSIE 6.0) " +
"(compatible; MSIE 6.0; Windows NT 5.1; " +
".NET CLR 1.1.4322; .NET CLR 2.0.50727)";
try
{
byte[] arr = client.DownloadData("http://checkip.amazonaws.com/");
string response = System.Text.Encoding.UTF8.GetString(arr);
return response.Trim();
}
catch (WebException ex)
{
// Reproduce timeout: http://checkip.amazonaws.com:81/
// trying with another site
try
{
byte[] arr = client.DownloadData("http://icanhazip.com/");
string response = System.Text.Encoding.UTF8.GetString(arr);
return response.Trim();
}
catch (WebException exc)
{ return "Undefined"; }
}
}
}
catch (Exception ex)
{
// TODO: Log trace
return "Undefined";
}
}
bonne partie est, les deux sites renvoient L'IP en format simple. Ainsi les opérations de chaîne sont évitées.
pour vérifier votre logique dans la clause catch , vous pouvez reproduire le délai en appuyant sur un port non disponible. eg: http://checkip.amazonaws.com:81 /
fondamentalement, je préfère utiliser quelques sauvegardes supplémentaires dans le cas où l'un des IP n'est pas accessible. J'ai donc utiliser cette méthode.
public static string GetExternalIPAddress()
{
string result = string.Empty;
try
{
using (var client = new WebClient())
{
client.Headers["User-Agent"] =
"Mozilla/4.0 (Compatible; Windows NT 5.1; MSIE 6.0) " +
"(compatible; MSIE 6.0; Windows NT 5.1; " +
".NET CLR 1.1.4322; .NET CLR 2.0.50727)";
try
{
byte[] arr = client.DownloadData("http://checkip.amazonaws.com/");
string response = System.Text.Encoding.UTF8.GetString(arr);
result = response.Trim();
}
catch (WebException)
{
}
}
}
catch
{
}
if (string.IsNullOrEmpty(result))
{
try
{
result = new WebClient().DownloadString("https://ipinfo.io/ip").Replace("\n", "");
}
catch
{
}
}
if (string.IsNullOrEmpty(result))
{
try
{
result = new WebClient().DownloadString("https://api.ipify.org").Replace("\n", "");
}
catch
{
}
}
if (string.IsNullOrEmpty(result))
{
try
{
result = new WebClient().DownloadString("https://icanhazip.com").Replace("\n", "");
}
catch
{
}
}
if (string.IsNullOrEmpty(result))
{
try
{
result = new WebClient().DownloadString("https://wtfismyip.com/text").Replace("\n", "");
}
catch
{
}
}
if (string.IsNullOrEmpty(result))
{
try
{
result = new WebClient().DownloadString("http://bot.whatismyipaddress.com/").Replace("\n", "");
}
catch
{
}
}
if (string.IsNullOrEmpty(result))
{
try
{
string url = "http://checkip.dyndns.org";
System.Net.WebRequest req = System.Net.WebRequest.Create(url);
System.Net.WebResponse resp = req.GetResponse();
System.IO.StreamReader sr = new System.IO.StreamReader(resp.GetResponseStream());
string response = sr.ReadToEnd().Trim();
string[] a = response.Split(':');
string a2 = a[1].Substring(1);
string[] a3 = a2.Split('<');
result = a3[0];
}
catch (Exception)
{
}
}
return result;
}
afin de mettre à jour le contrôle GUI (WPF, .NET 4.5), par exemple une étiquette j'utilise ce code
void GetPublicIPAddress()
{
Task.Factory.StartNew(() =>
{
var ipAddress = SystemHelper.GetExternalIPAddress();
Action bindData = () =>
{
if (!string.IsNullOrEmpty(ipAddress))
labelMainContent.Content = "IP External: " + ipAddress;
else
labelMainContent.Content = "IP External: ";
labelMainContent.Visibility = Visibility.Visible;
};
this.Dispatcher.InvokeAsync(bindData);
});
}
espère que c'est utile.
Ici est un exemple de l'application qui va inclure ce code.
public string GetClientIp() {
var ipAddress = string.Empty;
if (System.Web.HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"] != null) {
ipAddress = System.Web.HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString();
} else if (System.Web.HttpContext.Current.Request.ServerVariables["HTTP_CLIENT_IP"] != null &&
System.Web.HttpContext.Current.Request.ServerVariables["HTTP_CLIENT_IP"].Length != 0) {
ipAddress = System.Web.HttpContext.Current.Request.ServerVariables["HTTP_CLIENT_IP"];
} else if (System.Web.HttpContext.Current.Request.UserHostAddress.Length != 0) {
ipAddress = System.Web.HttpContext.Current.Request.UserHostName;
}
return ipAddress;
}
fonctionne parfaitement
using System.Net;
private string GetWorldIP()
{
String url = "http://bot.whatismyipaddress.com/";
String result = null;
try
{
WebClient client = new WebClient();
result = client.DownloadString(url);
return result;
}
catch (Exception ex) { return "127.0.0.1"; }
}
a utilisé loopback comme repli juste pour que les choses ne se cassent pas fatalement.
vous pouvez utiliser Telnet pour interroger programmatiquement votre routeur pour l'IP WAN.
Telnet partie
la partie Telnet peut être accomplie en utilisant, par exemple, ce code Telnet minimaliste comme API pour envoyer une commande Telnet à votre routeur et obtenir la réponse du routeur. Le reste de cette réponse suppose que vous avez configuré d'une manière ou d'une autre à envoyer un Telnet commandez et récupérez la réponse dans votre code.
Limitations de l'approche
je dirai d'emblée que l'un des inconvénients de l'interrogation du routeur par rapport à d'autres approches, c'est que le code que vous écrivez est susceptible d'être assez spécifique à votre modèle de routeur. Cela dit, cela peut être une approche utile qui ne s'appuie pas sur des serveurs externes, et vous pouvez de toute façon souhaiter accéder à votre routeur à partir de votre propre logiciel à d'autres fins, telles que comme la configuration et le contrôle, ce qui rend plus utile d'écrire du code spécifique.
exemple de commande de routeur et de réponse
l'exemple ci-dessous ne convient pas à tous les routeurs, mais illustre l'approche de principe. Vous aurez besoin de changer les détails pour s'adapter à vos commandes et réponses routeur.
par exemple, la façon d'obtenir votre routeur pour afficher L'IP WAN peut être la suivante Telnet commande:
connection list
la sortie peut consister en une liste de lignes de texte, une par connexion, avec l'adresse IP à l'offset 39. La ligne correspondant à la connexion WAN peut être identifiée à partir du mot "Internet" quelque part dans la ligne:
RESP: 3947 17.110.226. 13:443 146.200.253. 16:60642 [R..A] Internet 6 tcp 128
<------------------ 39 -------------><-- WAN IP -->
la sortie peut garnir chaque segment D'adresse IP de trois caractères avec des espaces, que vous devrez supprimer. (Qui est, dans l'exemple ci-dessus, vous devez activer "146.200.253. 16" dans "146.200.253.16".)
en expérimentant ou en consultant la documentation de référence pour votre routeur, vous pouvez établir la commande à utiliser pour votre routeur spécifique et comment interpréter la réponse du routeur.
Code pour obtenir L'IP WAN
(suppose que vous avez une méthode sendRouterCommand pour la partie Telnet-voir ci-dessus. )
en utilisant l'exemple de routeur décrit ci-dessus, le code suivant obtient L'IP WAN:
private bool getWanIp(ref string wanIP)
{
string routerResponse = sendRouterCommand("connection list");
return (getWanIpFromRouterResponse(routerResponse, out wanIP));
}
private bool getWanIpFromRouterResponse(string routerResponse, out string ipResult)
{
ipResult = null;
string[] responseLines = routerResponse.Split(new char[] { '\n' });
// RESP: 3947 17.110.226. 13:443 146.200.253. 16:60642 [R..A] Internet 6 tcp 128
//<------------------ 39 -------------><--- 15 --->
const int offset = 39, length = 15;
foreach (string line in responseLines)
{
if (line.Length > (offset + length) && line.Contains("Internet"))
{
ipResult = line.Substring(39, 15).Replace(" ", "");
return true;
}
}
return false;
}
L'API IPIFY est agréable, car il peut répondre dans le texte brut et JSON. Il peut aussi faire des callbacks, etc. Le seul problème est qu'il répond en IPv4, pas en 6.
j'ai remanié la réponse de @Academy of Programmer's au code plus court et l'ai modifié de sorte qu'il ne frappe que https:// URLs:
public static string GetExternalIPAddress()
{
string result = string.Empty;
string[] checkIPUrl =
{
"https://ipinfo.io/ip",
"https://checkip.amazonaws.com/",
"https://api.ipify.org",
"https://icanhazip.com",
"https://wtfismyip.com/text"
};
using (var client = new WebClient())
{
client.Headers["User-Agent"] = "Mozilla/4.0 (Compatible; Windows NT 5.1; MSIE 6.0) " +
"(compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)";
foreach (var url in checkIPUrl)
{
try
{
result = client.DownloadString(url);
}
catch
{
}
if (!string.IsNullOrEmpty(result))
break;
}
}
return result.Replace("\n", "").Trim();
}
}
Ou cette, il fonctionne très bien, je pense que pour ce dont j'avais besoin. C'est de ici .
public IPAddress GetExternalIP()
{
WebClient lol = new WebClient();
string str = lol.DownloadString("http://www.ip-adress.com/");
string pattern = "<h2>My IP address is: (.+)</h2>"
MatchCollection matches1 = Regex.Matches(str, pattern);
string ip = matches1(0).ToString;
ip = ip.Remove(0, 21);
ip = ip.Replace("
", "");
ip = ip.Replace(" ", "");
return IPAddress.Parse(ip);
}