Validando endereços IPv4 com regexp

Eu tenho tentado obter um regex eficiente para a validação do IPv4, mas sem muita sorte. Parecia que em um ponto eu tive com (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4} , mas produz alguns resultados estranhos:

 [chris@helios bashscripts]$ grep --version grep (GNU grep) 2.7 [chris@helios bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.1 192.168.1.1 [chris@helios bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.255 192.168.1.255 [chris@helios bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255 [chris@helios bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.2555 192.168.1.2555 

Eu fiz uma pesquisa para ver se isso já havia sido perguntado e respondido, mas outras respostas parecem simplesmente mostrar como determinar 4 grupos de 1-3 números, ou não funcionam para mim.

Alguma ideia? Obrigado!

Você já tem uma resposta em funcionamento, mas caso esteja curioso sobre o que havia de errado com sua abordagem original, a resposta é que você precisa de parênteses em torno de sua alternância, caso contrário, o (\.|$) Será necessário apenas se o número for menor que 200

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

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

Aceite :

 127.0.0.1 192.168.1.1 192.168.1.255 255.255.255.255 0.0.0.0 1.1.1.01 

Rejeitar :

 30.168.1.255.1 127.1 192.168.1.256 -1.2.3.4 3...3 

Experimente online com testes de unidade: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Regex não é a ferramenta para este trabalho. Seria melhor escrever um analisador que separa os quatro números e verifica se eles estão no intervalo [0,255]. O regex não funcional já é ilegível!

Endereço IPv4 (captura precisa) Corresponde de 0.0.0.0 a 255.255.255.255 Use essa regex para corresponder aos números de IP com precisão. Cada um dos 4 números é armazenado em um grupo de captura, para que você possa acessá-los para processamento adicional.

 \b (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]?)\. (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]?) \b 

retirado da biblioteca JGsoft RegexBuddy

Edit: this (\.|$) Parte parece estranho

Versão curta nova e melhorada

^(?:(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(\.(?!$)|$)){4}$

Ele usa o lookahead negativo (?!) Para remover o caso em que o ip pode terminar com a .

Resposta antiga

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

Eu acho que esta é a regex mais precisa e rigorosa, não aceita coisas como 000.021.01.0. parece que a maioria das outras respostas aqui e requerem regex adicional para rejeitar casos semelhantes a esse – ou seja, 0 números iniciais e um ip que termina com a .

Eu estava em busca de algo semelhante para endereços IPv4 – um regex que também impedia que os endereços IP privados comumente usados ​​fossem validados (192.168.xy, 10.xyz, 172.16.xy) e, portanto, usavam um look negativo para fazer isso:

 (?!(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.).*) (?!255\.255\.255\.255)(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|[1-9]) (\.(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|\d)){3} 

(Estes devem estar em uma linha de curso, formatados para fins de legibilidade em 3 linhas separadas) Visualização de expressão regular

Debuggex Demo

Pode não ser otimizado para velocidade, mas funciona bem quando se procura apenas endereços de Internet ‘reais’.

Coisas que irão (e devem) falhar:

 0.1.2.3 (0.0.0.0/8 is reserved for some broadcasts) 10.1.2.3 (10.0.0.0/8 is considered private) 172.16.1.2 (172.16.0.0/12 is considered private) 172.31.1.2 (same as previous, but near the end of that range) 192.168.1.2 (192.168.0.0/16 is considered private) 255.255.255.255 (reserved broadcast is not an IP) .2.3.4 1.2.3. 1.2.3.256 1.2.256.4 1.256.3.4 256.2.3.4 1.2.3.4.5 1..3.4 

IPs que irão (e devem) funcionar:

 1.0.1.0 (China) 8.8.8.8 (Google DNS in USA) 100.1.2.3 (USA) 172.15.1.2 (USA) 172.32.1.2 (USA) 192.167.1.2 (Italy) 

Fornecido no caso de alguém mais estar procurando validar ‘endereços IP da Internet que não incluam os endereços privados comuns’

Isso é um pouco mais do que alguns, mas é isso que eu uso para corresponder aos endereços IPv4. Simples sem compromissos.

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

Consegui construir um regex de todas as outras respostas.

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

Com máscara de sub-rede:

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

Teste para encontrar correspondências no texto, https://regex101.com/r/9CcMEN/2

A seguir estão as regras que definem as combinações válidas em cada número de um endereço IP:

  • Qualquer número de um ou dois dígitos.
  • Qualquer número de três dígitos começando com 1 .

  • Qualquer número de três dígitos começando com 2 se o segundo dígito for de 0 a 4 .

  • Qualquer número de três dígitos começando com 25 se o terceiro dígito for de 0 a 5 .

Vamos começar com (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.) , Um conjunto de quatro subexpressões aninhadas, e as veremos na ordem inversa. (\d{1,2}) corresponde a qualquer número de um ou dois dígitos ou números de 0 a 99 . (1\d{2}) corresponde a qualquer número de três dígitos começando com 1 ( 1 seguido por quaisquer dois dígitos) ou números 100 a 199 . (2[0-4]\d) corresponde aos números de 200 a 249 . (25[0-5]) corresponde aos números de 250 a 255 . Cada uma dessas subexpressões é incluída em outra subexpressão com um | entre cada (para que uma das quatro subexpressões tenha que corresponder, não todas). Depois que o intervalo de números vem \. para combinar . e, em seguida, toda a série (todas as opções numéricas mais \. ) é incluída em outra subexpressão e repetida três vezes usando {3} . Finalmente, o intervalo de números é repetido (desta vez sem o trailing \. ) Para coincidir com o número do endereço IP final. Ao restringir cada um dos quatro números a valores entre 0 e 255 , esse padrão pode de fato corresponder a endereços IP válidos e rejeitar endereços inválidos.

Trecho de: Ben Forta. “Aprendendo expressões regulares”.


Se nenhum caractere for desejado no início do endereço IP nem no final, ^ e $ metacaracteres devem ser usados, respectivamente.

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

Teste para encontrar correspondências no texto, https://regex101.com/r/uAP31A/1

  const char*ipv4_regexp = "\\b(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]?)\\." "(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]?)\\b"; 

Eu adaptei a expressão regular da biblioteca JGsoft RegexBuddy para a linguagem C (regcomp / regexec) e descobri que funciona, mas há um pequeno problema em alguns sistemas operacionais como o Linux. Essa expressão regular aceita endereços ipv4 como 192.168.100.009, onde 009 no Linux é considerado um valor octal, então o endereço não é o que você pensou. Eu mudei essa expressão regular da seguinte forma:

  const char* ipv4_regex = "\\b(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b"; 

usando essa expressione regular agora 192.168.100.009 não é um endereço ipv4 válido enquanto 192.168.100.9 está ok.

Eu modifiquei uma expressão regular para endereço multicast também e é o seguinte:

  const char* mcast_ipv4_regex = "\\b(22[4-9]|23[0-9])\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]?)\\." "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b"; 

Eu acho que você tem que adaptar a expressão regular para a linguagem que você está usando para desenvolver sua aplicação

Eu coloquei um exemplo em java:

  package utility; import java.util.regex.Matcher; import java.util.regex.Pattern; public class NetworkUtility { private static String ipv4RegExp = "\\b(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\b"; private static String ipv4MulticastRegExp = "2(?:2[4-9]|3\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d?|0)){3}"; public NetworkUtility() { } public static boolean isIpv4Address(String address) { Pattern pattern = Pattern.compile(ipv4RegExp); Matcher matcher = pattern.matcher(address); return matcher.matches(); } public static boolean isIpv4MulticastAddress(String address) { Pattern pattern = Pattern.compile(ipv4MulticastRegExp); Matcher matcher = pattern.matcher(address); return matcher.matches(); } } 
 -bash-3.2$ echo "191.191.191.39" | egrep '(^|[^0-9])((2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)\.{3} (2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)($|[^0-9])' 

>> 191.191.191.39

(Este é um DFA que corresponde a todo o espaço do addr (incluindo transmissões, etc.) e nada mais.

Eu acho que esse é o mais curto.

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

Eu achei esta amostra muito útil, além disso, permite diferentes notações ipv4.

código de amostra usando python:

  def is_valid_ipv4(ip4): """Validates IPv4 addresses. """ import re pattern = re.compile(r""" ^ (?: # Dotted variants: (?: # Decimal 1-255 (no leading 0's) [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2} | 0x0*[0-9a-f]{1,2} # Hexadecimal 0x0 - 0xFF (possible leading 0's) | 0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0's) ) (?: # Repeat 0-3 times, separated by a dot \. (?: [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2} | 0x0*[0-9a-f]{1,2} | 0+[1-3]?[0-7]{0,2} ) ){0,3} | 0x0*[0-9a-f]{1,8} # Hexadecimal notation, 0x0 - 0xffffffff | 0+[0-3]?[0-7]{0,10} # Octal notation, 0 - 037777777777 | # Decimal notation, 1-4294967295: 429496729[0-5]|42949672[0-8]\d|4294967[01]\d\d|429496[0-6]\d{3}| 42949[0-5]\d{4}|4294[0-8]\d{5}|429[0-3]\d{6}|42[0-8]\d{7}| 4[01]\d{8}|[1-3]\d{0,9}|[4-9]\d{0,8} ) $ """, re.VERBOSE | re.IGNORECASE) return pattern.match(ip4) <> None 
 ((\.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4} 

Este regex não aceita 08.8.8.8 ou 8.08.8.8 ou 8.8.08.8 ou 8.8.8.08

Encontra um endereço IP válido desde que o IP esteja em volta de qualquer caractere que não seja dígitos (atrás ou à frente do IP). 4 Backreferences criadas: $ + {first}. $ + {Second}. $ + {Third}. $ + {Forth}

 Find String: #any valid IP address (?(?< ![\d])(?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d])) #only valid private IP address RFC1918 (?(?< ![\d])(:?(:?(?10)[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])))|(:?(?172)[\.](?(:?1[6-9])|(:?2[0-9])|(:?3[0-1])))|(:?(?192)[\.](?168)))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d])) Notepad++ Replace String Option 1: Replaces the whole IP (NO Change): $+{IP} Notepad++ Replace String Option 2: Replaces the whole IP octect by octect (NO Change) $+{first}.$+{second}.$+{third}.$+{forth} Notepad++ Replace String Option 3: Replaces the whole IP octect by octect (replace 3rd octect value with 0) $+{first}.$+{second}.0.$+{forth} NOTE: The above will match any valid IP including 255.255.255.255 for example and change it to 255.255.0.255 which is wrong and not very useful of course. 

Substituindo a parte de cada octeto por um valor real, você pode construir sua própria busca e substituição, o que é realmente útil para alterar IPs em arquivos de texto:

 for example replace the first octect group of the original Find regex above: (?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])) with (?10) and (?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])) with (?216) and you are now matching addresses starting with first octect 192 only Find on notepad++: (?(?< ![\d])(?10)[\.](?216)[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d])) 

Você ainda pode executar Substituir usando grupos de referência anterior da mesma maneira de antes.

Você pode ter uma ideia de como as opções acima são compatíveis:

 cat ipv4_validation_test.txt Full Match: 0.0.0.1 12.108.1.34 192.168.1.1 10.249.24.212 10.216.1.212 192.168.1.255 255.255.255.255 0.0.0.0 Partial Match (IP Extraction from line) 30.168.1.0.1 -1.2.3.4 sfds10.216.24.23kgfd da11.15.112.255adfdsfds sfds10.216.24.23kgfd NO Match 1.1.1.01 3...3 127.1. 192.168.1.. 192.168.1.256 da11.15.112.2554adfdsfds da311.15.112.255adfdsfds 

Usando grep você pode ver os resultados abaixo:

 From grep: grep -oP '(?(?< ![\d])(?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt 0.0.0.1 12.108.1.34 192.168.1.1 10.249.24.212 10.216.1.212 192.168.1.255 255.255.255.255 0.0.0.0 30.168.1.0 1.2.3.4 10.216.24.23 11.15.112.255 10.216.24.23 grep -P '(?(?< ![\d])(?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt 0.0.0.1 12.108.1.34 192.168.1.1 10.249.24.212 10.216.1.212 192.168.1.255 255.255.255.255 0.0.0.0 30.168.1.0.1 -1.2.3.4 sfds10.216.24.23kgfd da11.15.112.255adfdsfds sfds10.216.24.23kgfd #matching ip addresses starting with 10.216 grep -oP '(?(?< ![\d])(?10)[\.](?216)[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt 10.216.1.212 10.216.24.23 10.216.24.23 

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


Acima será regex para o endereço IP como: 221.234.000.112 também para 221.234.0.112, 221.24.03.112, 221.234.0.1


Você pode imaginar todo o tipo de endereço como acima

Eu usaria o PCRE e a palavra-chave define :

 /^ ((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))$ (?(DEFINE) (?25[0-5]|2[0-4]\d|[01]?\d\d?)) /gmx 

Demonstração: https://regex101.com/r/IB7j48/2

A razão disso é evitar repetir o padrão (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) Quatro vezes. Outras soluções, como a abaixo, funcionam bem, mas não capturam cada grupo como seria solicitado por muitos.

 /^((\d+?)(\.|$)){4}/ 

A única outra maneira de ter 4 grupos de captura é repetir o padrão quatro vezes:

 /^(?\d+)\.(?\d+)\.(?\d+)\.(?\d+)$/ 

Capturar um ipv4 em perl é, portanto, muito fácil

 $ echo "Hey this is my IP address 138.131.254.8, bye!" | \ perl -ne 'print "[$1, $2, $3, $4]" if \ /\b((?&byte))\.((?&byte))\.((?&byte))\.((?&byte)) (?(DEFINE) \b(?25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)) /x' [138, 131, 254, 8] 

O regexp IPv4 mais preciso, direto e compacto que eu posso imaginar é

 ^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$ 

Mas o que acontece com o desempenho / eficiência de … Desculpe eu não sei, quem se importa?

Acho que muitas pessoas que estão lendo este post estarão procurando algo mais simples, mesmo que isso permita alguns endereços IP tecnicamente inválidos.

Isso é o mais simples que eu poderia fazer:

Python / Ruby / Perl:

 /(\d+(\.|$)){4}/ 

grep -E (GNU Grep 3.1), awk (versão 20070501) e sed:

 /([0-9]+(\.|$)){4}/ 

Puppet permitiu isso:

 /(\d+[\.$]){4}/ 

Tente isto:

 \b(([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.(2[0-5][0-5]|1[0-9][0-9]|[1-9][0-9]|[1-9]))\b 

Isso é regex funciona para mim:
"\< ((([1-9]|1[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([1-9]|1[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))\>"

O endereço IPv4 é uma coisa muito complicada.

Nota : O recuo e o revestimento são apenas para fins de ilustração e não existem no RegEx real.

 \b( (( (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9]) | 0[Xx]0*[0-9A-Fa-f]{1,2} | 0+[1-3]?[0-9]{1,2} )\.){1,3} ( (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9]) | 0[Xx]0*[0-9A-Fa-f]{1,2} | 0+[1-3]?[0-9]{1,2} ) | ( [1-3][0-9]{1,9} | [1-9][0-9]{,8} | (4([0-1][0-9]{8} |2([0-8][0-9]{7} |9([0-3][0-9]{6} |4([0-8][0-9]{5} |9([0-5][0-9]{4} |6([0-6][0-9]{3} |7([0-1][0-9]{2} |2([0-8][0-9]{1} |9([0-5] )))))))))) ) | 0[Xx]0*[0-9A-Fa-f]{1,8} | 0+[1-3]?[0-7]{,10} )\b 

Esses endereços IPv4 são validados pelo RegEx acima.

 127.0.0.1 2130706433 0x7F000001 017700000001 0x7F.0.0.01 # Mixed hex/dec/oct 000000000017700000001 # Have as many leading zeros as you want 0x0000000000007F000001 # Same as above 127.1 127.0.1 

Estes são rejeitados.

 256.0.0.1 192.168.1.099 # 099 is not a valid number 4294967296 # UINT32_MAX + 1 0x100000000 020000000000 
 String zeroTo255 = "([0-9]|[0-9][0-9]|(0|1)[0-9][0-9]|2[0-4][0-9]|25[0-5])"; it can contain single digit ie ([0-9]); It can contain two digits ie ([0-9][0-9]); range is (099 to 199)ie((0|1)[0-9][0-9]); range is (200 - 249) ie (2[0-9][0-9]) ; range is (250-255) ie(25[0-5]); 
 mysql> select ip from foo where ip regexp '^\\s*[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]\\s*';