Regulärer Ausdruck, der dem DNS-Hostnamen oder der IP-Adresse entspricht?

Hat jemand einen regulären Ausdruck zur Hand, der mit einem legalen DNS-Hostnamen oder einer IP-Adresse übereinstimmt?

Es ist einfach, eine zu schreiben, die in 95% der Fälle funktioniert, aber ich hoffe, dass etwas gut getestet wird, das genau den neuesten RFC-Spezifikationen für DNS-Hostnamen entspricht.

Sie können die folgenden regulären Ausdrücke separat oder durch Kombinieren in einem gemeinsamen ODER-Ausdruck verwenden.

ValidIpAddressRegex = "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$";

ValidHostnameRegex = "^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$";

ValidIpAddressRegex Spiele gültige IP - Adressen und ValidHostnameRegex gültige Hostnamen. Abhängig von der verwendeten Sprache muss \ möglicherweise mit \ maskiert werden.

ValidHostnameRegex ist gemäß RFC 1123 gültig . Ursprünglich gab RFC 952 an, dass Hostnamensegmente nicht mit einer Ziffer beginnen dürfen.

http://en.wikipedia.org/wiki/Hostname

Die ursprüngliche Spezifikation von Hostnamen in RFC 952 sah vor , dass Beschriftungen nicht mit einer Ziffer oder einem Bindestrich beginnen dürfen und nicht mit einem Bindestrich enden dürfen. Eine nachfolgende Spezifikation ( RFC 1123 ) erlaubte jedoch, dass Hostnamenbezeichnungen mit Ziffern beginnen.

Valid952HostnameRegex = "^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$";

Der reguläre Ausdruck des Sminks für den Hostnamen beachtet nicht die Beschränkung der Länge einzelner Labels innerhalb eines Hostnamens. Jedes Label innerhalb eines gültigen Hostnamens darf nicht länger als 63 Oktette sein.

ValidHostnameRegex = "^ ([a-zA-Z0-9] | [a-zA-Z0-9] [a-zA-Z0-9 \ -] {0,61} [a-zA-Z0-9]) \.
(\. ([a-zA-Z0-9] | [a-zA-Z0-9] [a-zA-Z0-9 \ -] {0,61} [a-zA-Z0-9])) * $ "

Beachten Sie, dass der Backslash am Ende der ersten Zeile (oben) die Unix-Shell-Syntax zum Teilen der langen Zeile ist. Es ist kein Teil des regulären Ausdrucks.

Hier ist nur der reguläre Ausdruck in einer einzelnen Zeile:

^ ([a-zA-Z0-9] | [a-zA-Z0-9] [a-zA-Z0-9 \ -] {0,61} [a-zA-Z0-9]) (\. ([a-zA-Z0-9] | [a-zA-Z0-9] [a-zA-Z0-9 \ -] {0,61} [a-zA-Z0-9])) * $

Sie sollten auch separat prüfen, ob die Gesamtlänge des Hostnamens 255 Zeichen nicht überschreiten darf . Weitere Informationen finden Sie in RFC-952 und RFC-1123.

Verwenden Sie den folgenden regulären Ausdruck, um eine gültige IP-Adresse abzugleichen:

(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}

anstatt:

([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])(\.([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])){3}

Erläuterung

Viele Regex-Engines entsprechen der ersten Möglichkeit in der ORSequenz. Versuchen Sie beispielsweise den folgenden regulären Ausdruck:

10.48.0.200

Prüfung

Testen Sie den Unterschied zwischen gut und schlecht

Ich kann den Top-Beitrag anscheinend nicht bearbeiten, daher füge ich hier meine Antwort hinzu.

Für den Hostnamen - einfache Antwort, am Beispiel egrep hier - http: //www.linuxinsight.com/how_to_grep_for_ip_addresses_using_the_gnu_egrep_utility.html

egrep '([[:digit:]]{1,3}\.){3}[[:digit:]]{1,3}'

Der Fall berücksichtigt jedoch keine Werte wie 0 im ersten Oktett und Werte größer als 254 (IP-Adresse) oder 255 (Netzmaske). Vielleicht würde eine zusätzliche if-Anweisung helfen.

Was den legalen DNS-Hostnamen betrifft, habe ich, vorausgesetzt, Sie suchen nur nach Internet-Hostnamen (und nicht nach Intranet), den folgenden Ausschnitt geschrieben, eine Mischung aus Shell / PHP, die jedoch als regulärer Ausdruck anwendbar sein sollte.

Gehen Sie zuerst zur ietf-Website, laden Sie eine Liste der legalen Domain-Namen der Ebene 1 herunter und analysieren Sie sie:

tld=$(curl -s http://data.iana.org/TLD/tlds-alpha-by-domain.txt |  sed 1d  | cut -f1 -d'-' | tr '\n' '|' | sed 's/\(.*\)./\1/')
echo "($tld)"

Das sollte Ihnen einen schönen Code geben, der die Rechtmäßigkeit von Top-Domain-Namen wie .com .org oder .ca überprüft

Fügen Sie dann den ersten Teil des Ausdrucks gemäß den hier angegebenen Richtlinien hinzu - http: //www.domainit.com/support/faq.mhtml?category=Domain_FAQ&question=9 (eine alphanumerische Kombination und ein '-' Symbol, Bindestrich sollte nicht enthalten sein der Anfang oder das Ende eines Oktetts.

(([a-z0-9]+|([a-z0-9]+[-]+[a-z0-9]+))[.])+

Dann setzen Sie alles zusammen (PHP preg_match Beispiel):

$pattern = '/^(([a-z0-9]+|([a-z0-9]+[-]+[a-z0-9]+))[.])+(AC|AD|AE|AERO|AF|AG|AI|AL|AM|AN|AO|AQ|AR|ARPA|AS|ASIA|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BIZ|BJ|BM|BN|BO|BR|BS|BT|BV|BW|BY|BZ|CA|CAT|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|COM|COOP|CR|CU|CV|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EDU|EE|EG|ER|ES|ET|EU|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GOV|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|INFO|INT|IO|IQ|IR|IS|IT|JE|JM|JO|JOBS|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MG|MH|MIL|MK|ML|MM|MN|MO|MOBI|MP|MQ|MR|MS|MT|MU|MUSEUM|MV|MW|MX|MY|MZ|NA|NAME|NC|NE|NET|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|ORG|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PRO|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|ST|SU|SV|SY|SZ|TC|TD|TEL|TF|TG|TH|TJ|TK|TL|TM|TN|TO|TP|TR|TRAVEL|TT|TV|TW|TZ|UA|UG|UK|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|XN|XN|XN|XN|XN|XN|XN|XN|XN|XN|XN|YE|YT|YU|ZA|ZM|ZW)[.]?$/i';

    if (preg_match, $pattern, $matching_string){
    ... do stuff
    }

Möglicherweise möchten Sie auch eine if-Anweisung hinzufügen, um zu überprüfen, ob die von Ihnen überprüfte Zeichenfolge kürzer als 256 Zeichen ist - http://www.ops.ietf.org/lists/namedroppers/namedroppers.2003/msg00964.html

Es ist erwähnenswert, dass es für die meisten Sprachen Bibliotheken gibt, die dies für Sie tun und häufig in die Standardbibliothek integriert sind. Und diese Bibliotheken werden wahrscheinlich viel häufiger aktualisiert als Code, den Sie vor vier Jahren aus einer Stapelüberlauf-Antwort kopiert und vergessen haben. Und natürlich analysieren sie die Adresse im Allgemeinen auch in eine verwendbare Form, anstatt Ihnen nur eine Übereinstimmung mit einer Reihe von Gruppen zu geben.

Beispiel: Erkennen und Parsen von IPv4 in (POSIX) C:

#include <arpa/inet.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
  for (int i=1; i!=argc; ++i) {
    struct in_addr addr = {0};
    printf("%s: ", argv[i]);
    if (inet_pton(AF_INET, argv[i], &addr) != 1)
      printf("invalid\n");
    else
      printf("%u\n", addr.s_addr);
  }
  return 0;
}

Offensichtlich funktionieren solche Funktionen nicht, wenn Sie beispielsweise versuchen, alle gültigen Adressen in einer Chat-Nachricht zu finden. Aber selbst dort ist es möglicherweise einfacher, einen einfachen, aber übereifrigen regulären Ausdruck zu verwenden, um potenzielle Übereinstimmungen zu finden, und dann die zu verwenden Bibliothek, um sie zu analysieren.

Zum Beispiel in Python:

>>> import ipaddress
>>> import re
>>> msg = "My address is 192.168.0.42; 192.168.0.420 is not an address"
>>> for maybeip in re.findall(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', msg):
...     try:
...         print(ipaddress.ip_address(maybeip))
...     except ValueError:
...         pass

def isValidHostname(hostname):

    if len(hostname) > 255:
        return False
    if hostname[-1:] == ".":
        hostname = hostname[:-1]   # strip exactly one dot from the right,
                                   #  if present
    allowed = re.compile("(?!-)[A-Z\d-]{1,63}(?<!-)$", re.IGNORECASE)
    return all(allowed.match(x) for x in hostname.split("."))

Ich denke, dies ist der beste IP-Validierungs-Regex. bitte einmal überprüfen !!!

^(([01]?[0-9]?[0-9]|2([0-4][0-9]|5[0-5]))\.){3}([01]?[0-9]?[0-9]|2([0-4][0-9]|5[0-5]))$

"^((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\.){3}(\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])$"

Dies funktioniert für gültige IP-Adressen:

regex = '^([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])[.]([0-9]|[1-9][0-9]|[1][0-9][0-9]|[2][0-5][0-5])$'

/^(?:[a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9]+[a-zA-Z0-9])(?:\.[a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9]+[a-zA-Z0-9])?$/

Hier ist ein regulärer Ausdruck, den ich in Ant verwendet habe, um eine Proxy-Host-IP oder einen Hostnamen aus ANT_OPTS zu erhalten. Dies wurde verwendet, um die Proxy-IP zu erhalten, damit ich einen Ant "isreachable" -Test ausführen konnte, bevor ich einen Proxy für eine gegabelte JVM konfigurierte.

^.*-Dhttp\.proxyHost=(\w{1,}\.\w{1,}\.\w{1,}\.*\w{0,})\s.*$

Ich fand, dass dies für IP-Adressen ziemlich gut funktioniert. Es wird wie die Top-Antwort validiert, stellt aber auch sicher, dass die IP isoliert ist, sodass nach oder vor der IP kein Text oder mehr Zahlen / Dezimalstellen stehen.

(? <! \ S) (?: (?: \ D | [1-9] \ d | 1 \ d \ d | 2 [0-4] \ d | 25 [0-5]) \ b |. \ b) {7} (?! \ S)

AddressRegex = "^(ftp|http|https):\/\/([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:[0-9]{1,5})$";

HostnameRegex =  /^(ftp|http|https):\/\/([a-z0-9]+\.)?[a-z0-9][a-z0-9-]*((\.[a-z]{2,6})|(\.[a-z]{2,6})(\.[a-z]{2,6}))$/i

Diese werden nur für diese Typüberprüfung verwendet

funktionieren nur, wenn http://www.kk.com http://www.kk.co.in

funktioniert nicht für

http://www.kk.com/ http: //www.kk.co.in.kk

http://www.kk.com/dfas http://www.kk.co.in/

Versuche dies:

((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)

es funktioniert in meinem Fall.

In Bezug auf IP-Adressen scheint es einige Debatten darüber zu geben, ob führende Nullen aufgenommen werden sollen. Es war einmal die übliche Praxis und wird allgemein akzeptiert, daher würde ich argumentieren, dass sie unabhängig von der aktuellen Präferenz als gültig gekennzeichnet werden sollten . Es gibt auch einige Unklarheiten darüber, ob Text vor und nach der Zeichenfolge validiert werden soll, und ich denke, dies sollte auch so sein. 1.2.3.4 ist eine gültige IP, 1.2.3.4.5 jedoch nicht, und weder der 1.2.3.4-Teil noch der 2.3.4.5-Teil sollten zu einer Übereinstimmung führen. Einige der Bedenken können mit diesem Ausdruck behandelt werden:

grep -E '(^|[^[:alnum:]+)(([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5])\.){3}([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5])([^[:alnum:]]|$)' 

Der unglückliche Teil hier ist die Tatsache, dass der Regex-Teil, der ein Oktett validiert, wiederholt wird, wie dies bei vielen angebotenen Lösungen der Fall ist. Obwohl dies besser ist als für Instanzen des Musters, kann die Wiederholung vollständig eliminiert werden, wenn Unterprogramme im verwendeten regulären Ausdruck unterstützt werden. Das nächste Beispiel aktiviert diese Funktionen mit dem -PSchalter von grepund nutzt auch die Lookahead- und Lookbehind-Funktionen. (Der von mir ausgewählte Funktionsname ist 'o' für Oktett. Ich hätte 'Oktett' als Namen verwenden können, wollte aber knapp sein.)

grep -P '(?<![\d\w\.])(?<o>([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5]))(\.\g<o>){3}(?![\d\w\.])'

Die Behandlung des Punkts kann tatsächlich zu einem falschen Negativ führen, wenn sich IP-Adressen in einer Datei mit Text in Form von Sätzen befinden, da der a-Punkt folgen könnte, ohne dass er Teil der gepunkteten Notation ist. Eine Variante des oben genannten würde das beheben:

grep -P '(?<![\d\w\.])(?<x>([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5]))(\.\g<x>){3}(?!([\d\w]|\.\d))'

>>> my_hostname = "testhostn.ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
True
>>> my_hostname = "testhostn....ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
False
>>> my_hostname = "testhostn.A.ame"
>>> print bool(re.match("^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$", my_hostname))
True

Das neue Netzwerkframework verfügt über fehlerhafte Initialisierer für struct IPv4Address und struct IPv6Address, die den IP-Adressenteil sehr einfach verarbeiten. Dies in IPv6 mit einem regulären Ausdruck zu tun, ist bei allen Verkürzungsregeln schwierig.

Leider habe ich keine elegante Antwort für den Hostnamen.

Beachten Sie, dass das Netzwerkframework neu ist, sodass Sie möglicherweise gezwungen sind, für neuere Betriebssystemversionen zu kompilieren.

import Network
let tests = ["192.168.4.4","fkjhwojfw","192.168.4.4.4","2620:3","2620::33"]

for test in tests {
    if let _ = IPv4Address(test) {
        debugPrint("\(test) is valid ipv4 address")
    } else if let _ = IPv6Address(test) {
        debugPrint("\(test) is valid ipv6 address")
    } else {
        debugPrint("\(test) is not a valid IP address")
    }
}

output:
"192.168.4.4 is valid ipv4 address"
"fkjhwojfw is not a valid IP address"
"192.168.4.4.4 is not a valid IP address"
"2620:3 is not a valid IP address"
"2620::33 is valid ipv6 address"

Wie wäre es damit?

([0-9]{1,3}\.){3}[0-9]{1,3}

auf php: filter_var(gethostbyname($dns), FILTER_VALIDATE_IP) == true ? 'ip' : 'not ip'

Suchen nach Hostnamen wie ... mywebsite.co.in, thangaraj.name, 18thangaraj.in, thangaraj106.in usw.,

[a-z\d+].*?\\.\w{2,4}$

Ich dachte über dieses einfache Regex-Übereinstimmungsmuster für die IP-Adressanpassung nach \ d + [.] \ D + [.] \ D + [.] \ D +