regex - vacio - ¿Expresión regular para hacer coincidir el nombre de host DNS o la dirección IP?

expresiones regulares para buscar texto (21)

¿Alguien tiene una expresión regular a mano que coincida con cualquier nombre de host DNS o dirección IP 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 los nombres de host DNS.

¿Qué tal esto?

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

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 que pudiera ejecutar una prueba de "acceso" de Ant antes de configurar un proxy para una JVM bifurcada.

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

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

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

Con respecto a las direcciones IP, parece que hay cierto debate sobre si incluir ceros a la izquierda. Una vez fue la práctica común y generalmente se acepta, por lo que argumentaría que deberían marcarse como válidos independientemente de la preferencia actual. También existe cierta ambigüedad sobre si el texto antes y después de la cadena debe validarse y, una vez más, creo que debería validarse. 1.2.3.4 es una IP válida, pero 1.2.3.4.5 no lo es, y ni la parte 1.2.3.4 ni la parte 2.3.4.5 deben 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 parte de expresiones regulares que valida un octeto se repite, como ocurre en muchas soluciones ofrecidas. Aunque esto es mejor que para las instancias del patrón, la repetición puede eliminarse por completo si las subrutinas son compatibles con la expresión regular que se está utilizando. El siguiente ejemplo habilita esas funciones con el conmutador -P de grep y también aprovecha la funcionalidad de búsqueda anticipada y de búsqueda detrás de. (El nombre de la función que seleccioné es ''o'' para octeto. Podría haber usado ''octeto'' como nombre, pero quería ser conciso.)

grep -P ''(?<![/d/w/.])(?<o>([0-1]?[0-9]{1,2}|2[0-4][0-9]|25[0-5]))(/./g<o>){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 que forme parte de la notación punteada. Una variante de lo anterior arreglaría eso:

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

Creo que esta es la mejor expresión regular de validación de IP. por favor revísalo 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]))$

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

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

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

La expresión regular del nombre de host de smink no observa la limitación de la longitud de las etiquetas 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]))*$"

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

Aquí está solo 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 hacer coincidir 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 de expresiones regulares coinciden con la primera posibilidad en la secuencia OR . Por ejemplo, pruebe la siguiente expresión regular:

10.48.0.200

Prueba

Prueba la diferencia entre el bien contra el mal

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

Para el nombre de host: respuesta fácil, en el ejemplo de egrep 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 tiene en cuenta valores como 0 en el primer octeto, y valores superiores a 254 (dirección IP) o 255 (máscara de red). Tal vez una declaración adicional si ayudaría.

En cuanto al nombre de host dns legal, siempre que esté comprobando solo los nombres de host de Internet (y no la intranet), escribí el siguiente fragmento, 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:

Eso debería darle un buen código de re que compruebe la legalidad del nombre de dominio superior, como .com .org o .ca

Luego agregue la primera parte de la expresión de acuerdo con 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 principio o fin de un octeto.

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

Luego póngalo todo junto (ejemplo de PHP preg_match):

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

También puede agregar una declaración if para comprobar que la cadena que verifica tiene menos de 256 caracteres: http://www.ops.ietf.org/lists/namedroppers/namedroppers.2003/msg00964.html

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

Puede usar las siguientes expresiones regulares por separado o combinándolas en una expresión OR 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 direcciones IP válidas y nombres de host válidos ValidHostnameRegex . Dependiendo del idioma que utilice, podría tener que escapar con /.

ValidHostnameRegex es válido según RFC 1123 . Originalmente, RFC 952 especificaba que los segmentos del nombre 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 exigía que las etiquetas no pudieran comenzar con un dígito o un guión, y no deben terminar con un guión. Sin embargo, una especificación posterior ( RFC 1123 ) permitió que las etiquetas de nombre 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])$";

Vale la pena señalar que existen bibliotecas para la mayoría de los idiomas que lo hacen 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 Desbordamiento de pila hace cuatro años y se olvidó. Y, por supuesto, también generalmente analizarán la dirección en alguna forma utilizable, en lugar de simplemente darle una coincidencia con un grupo de grupos.

Por ejemplo, detectando y analizando IPv4 en (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; }

Obviamente, tales funciones no funcionarán si está intentando, 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 posibles coincidencias, y luego usar la 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

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

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.

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

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

/^(?:[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 же есть

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

Esto se usa solo para esta validación de tipo.

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/

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

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