¿Expresión regular para coincidir con el nombre de host DNS o la dirección IP?

¿Alguien tiene a mano una expresión regular que coincida con cualquier nombre de host o dirección IP DNS legal?

Es fácil escribir uno que funcione el 95% del tiempo, pero espero obtener algo que esté bien probado para que coincida exactamente con las últimas especificaciones RFC para nombres de host DNS.

Puede usar las siguientes expresiones regulares por separado o combinándolas en una expresión O conjunta.

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 coincide con las direcciones IP válidas y los nombres de host válidos ValidHostnameRegex . Dependiendo del idioma que use \ podría tener que escapar con \.


ValidHostnameRegex es válido según RFC 1123 . Originalmente, el RFC 952 especificaba que los segmentos de nombres de host no podían comenzar con un dígito.

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

La especificación original de nombres de host en RFC 952 , ordenaba que las tags no podían comenzar con un dígito o con un guión, y no debe terminar con un guión. Sin embargo, una especificación posterior ( RFC 1123 ) permitió que las tags de nombres de host comenzaran con dígitos.

 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])$"; 

La expresión regular del nombre de host de smink no observa la limitación en la longitud de las tags individuales dentro de un nombre de host. Cada etiqueta dentro de un nombre de host válido no puede tener más de 63 octetos de longitud.

  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])) ps 

Tenga en cuenta que la barra invertida al final de la primera línea (arriba) es la syntax del shell de Unix para dividir la línea larga. No es parte de la expresión regular en sí misma.

Aquí solo está la expresión regular sola en una sola línea:

  ^ ([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])) * $ 

También debe verificar por separado que la longitud total del nombre de host no debe exceder los 255 caracteres . Para obtener más información, consulte RFC-952 y RFC-1123.

Para que coincida con una dirección IP válida , use la siguiente expresión regular:

 (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} 

en lugar de:

 ([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} 

Explicación

Muchos motores regex coinciden con la primera posibilidad en la secuencia OR . Por ejemplo, prueba la siguiente expresión regular:

 10.48.0.200 

Prueba

Pruebe la diferencia entre bueno contra malo

Parece que no puedo editar la publicación principal, así que agregaré mi respuesta aquí.

Para el nombre de host – respuesta fácil, en egrep ejemplo aquí – http: //www.linuxinsight.com/how_to_grep_for_ip_addresses_using_the_gnu_egrep_utility.html

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

Aunque el caso no cuenta para valores como 0 en el octeto del puño, y valores mayores que 254 (direcciones IP) o 255 (máscara de red). Tal vez una statement if adicional ayudaría.

En cuanto al nombre de host dns legal, siempre que esté buscando solo nombres de host de Internet (y no de intranet), escribí el siguiente recorte, una mezcla de shell / php pero debería ser aplicable como cualquier expresión regular.

primero vaya al sitio web de ietf, descargue y analice una lista de nombres de dominio legales de nivel 1:

 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)" 

Eso debería darte una buena pieza de código de retorno que verifica la legalidad del nombre de dominio superior, como .com .org o .ca

A continuación, agregue la primera parte de la expresión según las pautas que se encuentran aquí: http: //www.domainit.com/support/faq.mhtml?category=Domain_FAQ&question=9 (cualquier combinación alfanumérica y el símbolo ‘-‘, el guión no debe estar en el comienzo o el final de un octeto.

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

Luego póngalo todo junto (PHP preg_match example):

 $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 } 

Es posible que también desee agregar una statement if para verificar que la cadena que está marcando es más corta que 256 caracteres – http://www.ops.ietf.org/lists/namedroppers/namedroppers.2003/msg00964.html

 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("(?!-)[AZ\d-]{1,63}(?< !-)$", re.IGNORECASE) return all(allowed.match(x) for x in hostname.split(".")) 

Creo que esta es la mejor expresión regular de validación Ip. por favor verifíquelo una vez!

 ^(([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]))$ 
 /^(?:[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])?$/ 

localhost же есть

 "^((\\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])$" 

Esto funciona para direcciones IP válidas:

 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])$' 

Vale la pena señalar que hay bibliotecas para la mayoría de los idiomas que hacen esto por usted, a menudo integradas en la biblioteca estándar. Y es probable que esas bibliotecas se actualicen mucho más a menudo que el código que copió de una respuesta de Stack Overflow hace cuatro años y lo olvidó. Y, por supuesto, generalmente también analizarán la dirección en una forma utilizable, en lugar de simplemente darle una coincidencia con un grupo de grupos.

Por ejemplo, detectar y analizar IPv4 en (POSIX) C:

 #include  #include  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; } 

Obviamente, esas funciones no funcionarán si intentas, por ejemplo, encontrar todas las direcciones válidas en un mensaje de chat, pero incluso allí, puede ser más fácil usar una expresión regular simple pero demasiado entusiasta para encontrar coincidencias potenciales, y luego usar el biblioteca para analizarlos.

Por ejemplo, en 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 

Aquí hay una expresión regular que utilicé en Ant para obtener una IP de host proxy o un nombre de host de ANT_OPTS. Esto se usó para obtener la IP del proxy para poder ejecutar una prueba “inalcanzable” de Ant antes de configurar un proxy para una JVM bifurcada.

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

Encontré que esto funciona bastante bien para las direcciones IP. Se valida como la respuesta superior, pero también se asegura de que la ip esté aislada, por lo que no hay texto o más números / decimales después o antes de la ip.

(? < ! \ 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-]*((\.[az]{2,6})|(\.[az]{2,6})(\.[az]{2,6}))$/i 

esto se usa solo para este tipo de validación

funciona solo si http://www.kk.com http://www.kk.co.in

no funciona para

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

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

 public string GetPublicIP() { var direction = string.Empty; var request = WebRequest.Create("http://checkip.dyndns.org/"); using (var response = request.GetResponse()) using (var stream = new StreamReader(response.GetResponseStream())) { direction = stream.ReadToEnd(); } var matches = matchIp.Match(direction); return matches.Captures.Count != 0 ? matches.Captures[0].Value : string.Empty; } 

prueba esto:

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

funciona en mi caso

En cuanto a las direcciones IP, parece que hay cierto debate sobre si incluir ceros a la izquierda. Alguna vez fue una práctica común y generalmente aceptada, por lo que yo argumentaría que deberían marcarse como válidas independientemente de la preferencia actual. También hay cierta ambigüedad sobre si el texto antes y después de la cadena debe ser validado y, de nuevo, creo que debería. 1.2.3.4 es un IP válido pero 1.2.3.4.5 no lo es y ni la porción 1.2.3.4 ni la porción 2.3.4.5 deberían dar como resultado una coincidencia. Algunas de las preocupaciones se pueden manejar con esta expresión:

 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:]]|$)' 

La parte desafortunada aquí es el hecho de que la porción de expresiones regulares que valida un octeto se repite, como ocurre en muchas soluciones ofrecidas. Aunque esto es mejor que para instancias del patrón, la repetición puede eliminarse por completo si las subrutinas son compatibles con la expresión regular que se utiliza. El siguiente ejemplo habilita esas funciones con el interruptor -P de grep y también aprovecha la funcionalidad de mirar hacia adelante y mirar hacia atrás. (El nombre de la función que seleccioné es ‘o’ para octeto. Pude haber usado ‘octeto’ como el nombre, pero quería ser escueto.)

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

El manejo del punto en realidad podría crear falsos negativos si las direcciones IP están en un archivo con texto en forma de oraciones, ya que el período podría seguir sin ser parte de la notación punteada. Una variante de lo anterior arreglaría eso:

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

¿Qué tal esto?

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

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

Comprobando nombres de host como … mywebsite.co.in, thangaraj.name, 18thangaraj.in, thangaraj106.in etc.,

 [az\d+].*?\\.\w{2,4}$ 

Pensé en este patrón simple de coincidencia de expresiones regulares para la coincidencia de direcciones IP \ d + [.] \ D + [.] \ D + [.] \ D +