Votre outil d'analyse de réseau est particulièrement difficile à saisir et se bloque immédiatement si vous lui fournissez une adresse IPv4 qui contient des caractères incorrects ou n'est pas correctement formatée.

Une adresse IPv4 est une adresse numérique 32 bits écrite en quatre nombres séparés par des points. Chaque nombre peut être compris entre zéro et 255 .

Nous devons écrire un outil pour pré-valider l'entrée pour éviter ces plantages, et notre outil spécifique est difficile: un format valide ressemblera à l' a.b.c.dendroit où a, b, c et d:

• Peut être un 0ou un nombre naturel sans zéros non significatifs .
• Doit être compris entre 0 et 255 (inclus).
• Devrait pas contenir des symboles spéciaux comme +, -, ,et d' autres.
• Doit être décimal (base 10)

Entrée : une chaîne

Sortie : valeur Truthy ou Falsey (valeurs arbitraires également acceptées)

Cas de test :

Input            |  Output  |  Reason
                 |          |
- 1.160.10.240   |  true    |
- 192.001.32.47  |  false   |  (leading zeros present)
- 1.2.3.         |  false   |  (only three digits)
- 1.2.3          |  false   |  (only three digits)
- 0.00.10.255    |  false   |  (leading zeros present)
- 1.2.$.4        |  false   |  (only three digits and a special symbol present)
- 255.160.0.34   |  true    |
- .1.1.1         |  false   |  (only three digits)
- 1..1.1.1       |  false   |  (more than three periods)
- 1.1.1.-0       |  false   |  (special symbol present)
- .1.1.+1        |  false   |  (special symbol present)
- 1 1 1 1        |  false   |  (no periods)
- 1              |  false   |  (only one digit)
- 10.300.4.0     |  false   |  (value over 255)
- 10.4F.10.99    |  false   |  (invalid characters)
- fruit loops    |  false   |  (umm...)
- 1.2.3.4.5      |  false   |  (too many periods/numbers)
- 0.0.0.0        |  true    |
- 0.0 0.0.       |  false   |  (periods misplaced)
- 1.23..4        |  false   |  (a typo of 1.2.3.4)
- 1:1:1:1:1:1:1:1|  false   |  (an IPv6 address, not IPv4)

Il s'agit de code-golf , donc le moins d'octets gagnera!

Remarque pour les utilisateurs - si vous souhaitez ajouter d'autres cas de test, vous êtes les bienvenus (en suggérant une modification). Mais assurez-vous que les cas de test ne se répètent pas! Merci

Code machine X86_64: 18 16 octets

Edit: Cette réponse ne fonctionne pas tout à fait, car

1. J'utilise inet_ptondes bibliothèques C standard, ce qui signifie que j'ai besoin de l'extern. Je n'ai cependant pas inclus l'extern dans mon nombre d'octets.
2. J'ai utilisé la zone rouge en conséquence pour l'adresse réelle, mais j'ai appelé une fonction qui aurait également pu utiliser la zone rouge. Heureusement, cela ne fonctionne pas sur ma machine, mais une compilation de bibliothèque standard étrange pourrait l'utiliser, ce qui pourrait entraîner un comportement indéfini.

Et oui, le tout se fait à peu près par une fonction déjà écrite

Quoi qu'il en soit, c'est ce que j'ai obtenu: 48 89 fe 6a 02 5f 48 8d 54 24 80 e9 00 00 00 00

Assemblée:

section .text
    extern inet_pton
    global ipIsValid

ipIsValid:
    mov rsi, rdi
    ;mov rdi, 2 ; change to 10 for ipv6
    push 2
    pop rdi ; thank you peter
    lea rdx, [rsp - 128]
    jmp inet_pton

Explication:

Jetez un oeil à inet_pton(3). Il prend une adresse IP de chaîne et la place dans un tampon que vous pouvez utiliser avec struct sockaddr. Il prend 3 arguments: la famille d'adresses ( AF_INET(ipv4), 2 ou AF_INET6(ipv6), 10), la chaîne de l'adresse ip et un pointeur vers la sortie. Il renvoie 1 en cas de succès, 0 pour une adresse non valide ou -1 pour lorsque la famille d'adresses n'est ni l'un AF_INETni l'autre AF_INET6(ce qui ne se produira jamais car je lui passe une constante).

Je déplace donc simplement la chaîne vers le registre pour le deuxième argument, je mets le premier registre à 2 et je mets le troisième registre dans la zone rouge (128 octets en dessous du pointeur de pile) car je me fiche du résultat. Ensuite , je peux tout simplement jmppour inet_ptonet laisser que le retour directement à l'appelant!

J'ai fait tourner ce programme de test rapide pour tester vos cas:

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

extern int ipIsValid(char *);

int main(){
    char *addresses[] = {
        "1.160.10.240",
        "192.001.32.47",
        "1.2.3.",
        "1.2.3",
        "0.00.10.255",
        "1.2.$.4",
        "255.160.0.34",
        ".1.1.1",
        "1..1.1.1",
        "1.1.1.-0",
        ".1.1.+1",
        "1 1 1 1",
        "1",
        "10.300.4.0",
        "10.4F.10.99",
        "fruit loops",
        "1.2.3.4.5",
        NULL
    };

    for(size_t i = 0; addresses[i] != NULL; ++i){
        printf("Address %s:\t%s\n", addresses[i],
            ipIsValid(addresses[i]) ? "true" : "false");
    }
    return 0;
}

Assemblez avec nasm -felf64 assembly.asm, compilez avec gcc -no-pie test.c assembly.o, et vous obtiendrez:

Address 1.160.10.240:   true
Address 192.001.32.47:  false
Address 1.2.3.: false
Address 1.2.3:  false
Address 0.00.10.255:    false
Address 1.2.$.4:    false
Address 255.160.0.34:   true
Address .1.1.1: false
Address 1..1.1.1:   false
Address 1.1.1.-0:   false
Address .1.1.+1:    false
Address 1 1 1 1:    false
Address 1:  false
Address 10.300.4.0: false
Address 10.4F.10.99:    false
Address fruit loops:    false
Address 1.2.3.4.5:  false

Je pourrais rendre cela beaucoup plus petit si l'appelant devait passer AF_INETou AF_INET6à la fonction

Java (JDK) , 63 octets

s->("."+s).matches("(\\.(25[0-5]|(2[0-4]|1\\d|[1-9])?\\d)){4}")

Essayez-le en ligne!

Crédits

• -1 octet grâce à Kevin Cruijssen
• l4m2 pour montrer le cas précédemment défaillant .1.1.1.1.

JavaScript (Node.js) , 43 octets

x=>x.split`.`.map(t=>[t&255]==t&&[])==`,,,`

Essayez-le en ligne!

JavaScript (Node.js) , 46 octets

x=>x.split`.`.every(t=>k--&&[t&255]==t,k=4)*!k

Essayez-le en ligne!

utilisé la partie d'Arnauld

JavaScript (Node.js) , 54 53 51 octets

x=>x.split`.`.every(t=>k--*0+t<256&[~~t]==t,k=4)*!k

Essayez-le en ligne!

-2B pour 0+t<256, -1B de Patrick Stephansen, + 1B pour éviter l'entrée1.1.1.1e-80

Solution RegExp 58 54 octets

s=>/^((2(?!5?[6-9])|1|(?!0\d))\d\d?\.?\b){4}$/.test(s)

Merci Deadcode pour 3 octets

PHP , 39 36 octets

<?=+!!filter_var($argv[1],275,5**9);

Essayez-le en ligne!

275 ressemble à la constante FILTER_VALIDATE_IP

5 ** 9 est utilisé à la place de la constante FILTER_FLAG_IPV4. C'est suffisant, car 5**9 & FILTER_FLAG_IPV4c'est vrai, c'est exactement ce que fait PHP en arrière-plan, comme l'a souligné Benoit Esnard.

Ici, filter_varrenvoie le premier argument, s'il s'agit d'une adresse IPv4 valide, ou faux s'il ne l'est pas. Avec +!!, nous produisons la sortie requise par le défi.

PHP, 36 octets

echo(ip2long($argv[1])===false?0:1);

ip2longest une fonction intégrée bien connue .

Perl 6 , 22 21 20 octets

-1 octet grâce à Phil H.

{?/^@(^256)**4%\.$/}

Essayez-le en ligne!

Explication

{                  }  # Anonymous Block
  /               /   # Regex match
   ^             $    # Anchor to start/end
    @(    )           # Interpolate
      ^256            #   range 0..255,
                      #   effectively like (0|1|2|...|255)
           **4        # Repeated four times
              %\.     # Separated by dot
 ?                    # Convert match result to Bool

05AB1E , 26 24 23 22 23 octets

'.¡©g4Q₅Ý®å`®1šDïþJsJQP

-1 octet grâce à @Emigna .
+1 octet pour le cas de test de correction de bogue 1.1.1.1E1renvoyant incorrectement un résultat véridique.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

'.¡              '# Split the (implicit) input by "."
   ©              # Save it in the register (without popping)
    g4Q           # Check that there are exactly 4 numbers
    ₅Ý®å          # Check for each of the numbers that they are in the range [0,255],
        `         # and push the result for each number separated onto the stack
    ®1šDïþJsJQ    # Check that each number does NOT start with a "0" (excluding 0s itself),
                  # and that they consist of digits only
              P   # Check if all values on the stack are truthy (and output implicitly)

PowerShell, 59 51 49 octets

-8 octets, merci @AdmBorkBork

-2 octets, trueou falseautorisé par l'auteur

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

Script de test:

$f = {

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

}

@(
    ,("1.160.10.240" , $true)
    ,("192.001.32.47" , $false)
    ,("1.2.3." , $false)
    ,("1.2.3" , $false)
    ,("0.00.10.255" , $false)
    ,("192.168.1.1" , $true)
    ,("1.2.$.4" , $false)
    ,("255.160.0.34" , $true)
    ,(".1.1.1" , $false)
    ,("1..1.1.1" , $false)
    ,("1.1.1.-0" , $false)
    ,("1.1.1.+1" , $false)
    ,("1 1 1 1" , $false)
    ,("1"            ,$false)
    ,("10.300.4.0"   ,$false)
    ,("10.4F.10.99"  ,$false)
    ,("fruit loops"  ,$false)
    ,("1.2.3.4.5"    ,$false)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

Sortie:

True: True : 1.160.10.240
True: False : 192.001.32.47
True: False : 1.2.3.
True: False : 1.2.3
True: False : 0.00.10.255
True: True : 192.168.1.1
True: False : 1.2.$.4
True: True : 255.160.0.34
True: False : .1.1.1
True: False : 1..1.1.1
True: False : 1.1.1.-0
True: False : 1.1.1.+1
True: False : 1 1 1 1
True: False : 1
True: False : 10.300.4.0
True: False : 10.4F.10.99
True: False : fruit loops
True: False : 1.2.3.4.5

Explication:

Le script essaie d'analyser une chaîne d'arguments pour construire un objet .NET, IPAddress .

• retourner $truesi objectcréé et l'argument chaîne est égal à une représentation sous forme de chaîne de object(adresse normalisée par object.toString())
• retourner $falseautrement

PowerShell, 59 56 54 octets, 'n'utilisez pas d'alternative .NET lib'

-3 octets, trueou falseautorisé par l'auteur

-2 octets, merci à @ Deadcode pour la regexp cool.

".$args"-match'^(\.(2(?!5?[6-9])|1|(?!0\B))\d\d?){4}$'

Essayez-le en ligne!

Merci @ Olivier Grégoire pour l'expression régulière originale.

C (gcc) / POSIX, 26 octets

f(s){s=inet_pton(2,s,&s);}

Essayez-le en ligne!

Fonctionne comme du code 64 bits sur TIO mais nécessite probablement cela sizeof(int) == sizeof(char*)sur d'autres plateformes.

PHP 7+, 37 35 32 octets

Cela utilise la fonction intégrée filter_var, pour valider qu'il s'agit d'une adresse IPv4 .

Pour que cela fonctionne, vous devez passer la clé isur une demande GET.

<?=filter_var($_GET[i],275,5**9);

Ne produira rien (pour un falsyrésultat) ou l'IP (pour un truthyrésultat), selon le résultat.

Vous pouvez essayer ceci sur: http://sandbox.onlinephpfunctions.com/code/639c22281ea3ba753cf7431281486d8e6e66f68e http://sandbox.onlinephpfunctions.com/code/ff6aaeb2b2d0e0ac43f48125de0549320bc071b4

Cela utilise directement les valeurs suivantes:

• 275 = FILTER_VALIDATE_IP
• 1 << 20 = 1048576 = FILTER_FLAG_IPV4
• 5 ** 9 = 1953125 (qui a le bit requis comme "1", pour 1048576)

Merci à Benoit Esnard pour cette astuce qui m'a fait économiser 1 octet!

Merci à Titus de m'avoir rappelé les changements apportés au défi.

J'ai cherché à utiliser la fonction ip2long, mais elle fonctionne avec des adresses IP non complètes.

Les adresses IPv4 non complètes sont considérées comme non valides dans ce défi.

S'ils étaient autorisés, ce serait le code final (uniquement pour PHP 5.2.10):

<?=ip2long($_GET[i]);

Actuellement, il n'est pas explicite dans la documentation que cela cessera de fonctionner (en cas de passage d'une adresse IP incomplète) avec les versions PHP plus récentes.

Après les tests, a confirmé que c'était le cas.

Merci à nwellnhof pour le conseil!

Python 3: 81 78 70 69 66 octets

['%d.%d.%d.%d'%(*x.to_bytes(4,'big'),)for x in range(16**8)].count

Parcourez toutes les adresses IPv4 possibles, obtenez la représentation sous forme de chaîne et comparez-la à l'entrée. Ça prend du temps à courir.

EDIT: Suppression de 3 octets en passant du programme complet à la fonction anonyme.

EDIT2: Suppression de 8 octets avec l'aide de xnor

EDIT3: Suppression de 1 octet en utilisant une carte décompressée au lieu de la compréhension de la liste

EDIT4: Suppression de 3 octets en utilisant la compréhension de liste au lieu du ipaddressmodule

C # (Visual C # Interactive Compiler) , 84 79 65 octets

s=>s.Split('.').Sum(t=>byte.TryParse(t,out var b)&t==b+""?1:5)==4

Essayez-le en ligne!

-5 et -14 octets enregistrés grâce à @dana!

# C # (Visual C # Interactive Compiler) , 61 octets

s=>s.Count(c=>c==46)==3&IPAddress.TryParse(s,out IPAddress i)

Essayez-le en ligne!

Ceci est un travail en cours de réalisation. Le code utilise System.Net(+17 octets si vous le comptez). si vous vous demandez pourquoi je compte et analyse:

La limitation avec la méthode IPAddress.TryParse est qu'elle vérifie si une chaîne peut être convertie en adresse IP, donc si elle est fournie avec une valeur de chaîne comme "5", elle la considère comme "0.0.0.5".

la source

Comme l'a dit @milk en commentaire, il échouera en effet sur les zéros non significatifs. Ainsi, le 61 octets ne fonctionne pas.

Python 2 , 85 82 81 octets

-1 octet grâce à Kevin Cruijssen

from ipaddress import*
I=input()
try:r=I==str(IPv4Address(I))
except:r=0
print~~r

Essayez-le en ligne!

La réponse à 113 octets est supprimée car elle échoue pour1.1.1.1e-80

Japt, 17 15 octets

q.
ʶ4«Uk#ÿòs)Ê

Essayez-le ou exécutez tous les cas de test ou vérifiez des cas de test supplémentaires à partir des commentaires de défi

Explication

Nous divisons en un tableau activé ., vérifions que la longueur de ce tableau est égale à 4ET que la longueur lorsque tous les éléments de la plage en ["0","255"]sont supprimés est falsey ( 0).

                 :Implicit input of string U
q.               :Split on "."
\n               :Reassign resulting array to U
Ê                :Length of U
 ¶4              :Equals 4?
   «             :&&!
    Uk           :Remove from U
      #ÿ         :  255
        ò        :  Range [0,255]
         s       :  Convert each to a string
          )      :End removal
           Ê     :Length of resulting array

Mathematica, 39 31 octets

Version originale:

¬FailureQ[Interpreter["IPAddress"][#]]&

Version modifiée (merci à Misha Lavrov)

 AtomQ@*Interpreter["IPAddress"]

qui retourne Truesi l'entrée est une adresse IP valide ( essayez-la ).

Au cas où vous insisteriez pour obtenir 1 et à la 0place, 7 octets supplémentaires seraient nécessaires:

Boole/@AtomQ@*Interpreter["IPAddress"]

JavaScript (ES6), 49 octets

Renvoie une valeur booléenne.

s=>[0,1,2,3].map(i=>s.split`.`[i]&255).join`.`==s

Essayez-le en ligne!

Python 2, 93 89 67 53 octets

[i==`int(i)&255`for i in input().split('.')]!=[1]*4>_

Essayez-le en ligne!

Merci à Dennis d'avoir rasé encore 14 octets sur les comparaisons internes et le code de sortie.

Un merci spécial à Jonathan Allan pour le rasage de 22 octets et un correctif logique! Pesky essayer / sauf Begone!

Prendre des chaînes correctement formatées au lieu d'octets bruts rase 4 octets, merci Jo King.

sfk , 176 octets

* était à l'origine Bash + SFK mais TIO a depuis ajouté un wrapper SFK approprié

xex -i "_[lstart][1.3 digits].[1.3 digits].[1.3 digits].[1.3 digits][lend]_[part2]\n[part4]\n[part6]\n[part8]_" +xed _[lstart]0[digit]_999_ +hex +linelen +filt -+1 -+2 +linelen

Essayez-le en ligne!

Python3 Bash * 60

* Aussi d'autres coquilles. Toute personne pour laquelle le test de vérité / fausse passe sur un code de sortie de programme

read I
python3 -c "from ipaddress import*;IPv4Address('$I')"

Explication

Le problème avec une solution Python pure est qu'un crash de programme est considéré comme indéterminé. Nous pourrions utiliser un "lot" de code pour convertir une exception en une valeur vraie / fasly appropriée. Cependant, à un moment donné, l'interpréteur Python gère cette exception non interceptée et retourne un code de sortie non nul. Pour le faible coût de changement de langue vers votre shell Unix préféré, nous pouvons enregistrer un peu de code!

Bien sûr, cela est vulnérable aux attaques par injection ... Des entrées telles que 1.1.1.1'); print('Doing Something Evilsont une menace non atténuée!

ECMAScript regex pur, 41 octets

^((2(?!5?[6-9])|1|(?!0\B))\d\d?\.?\b){4}$

Essayez-le en ligne!
Essayez-le sur regex101

Je pense que la logique de ce regex parle d'elle-même, donc je vais simplement faire une jolie impression mais pas le commenter:

^
(
    (
        2(?!5?[6-9])
    |
        1
    |
        (?!0\B)
    )
    \d\d?
    \.?\b
){4}
$

Cela peut être utilisé pour raser 2 octets des autres réponses suivantes:

• Olivier Grégoire (Java (JDK))
• l4m2 (JavaScript (Node.js))
• mazzy (PowerShell)
• Kevin Cruijssen (Retina)

Here is an alternative version that allows leading zeros, but does so consistently (octets may be represented by a maximum of 3 decimal digits):

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

Or allow any number of leading zeros:

^(0*(2(?!5?[6-9])|1?)\d\d?\.?\b){4}$

Red, 106 bytes

func[s][if error? try[t: load s][return off]if 4 <> length? t[return off]s =
form as-ipv4 t/1 t/2 t/3 t/4]

Try it online!

Returnd true or false

Explanation:

f: func [ s ] [
    if error? try [                  ; checks if the execution of the next block result in an error
        t: load s                    ; loading a string separated by '.' gives a tuple   
    ] [                              ; each part of which must be in the range 0..255
        return off                   ; if there's an error, return 'false' 
    ]
    if 4 <> length? t [              ; if the tuple doesn't have exactly 4 parts
        return off                   ; return 'false'  
    ]
    s = form as-ipv4 t/1 t/2 t/3 t/4 ; is the input equal to its parts converted to an IP adress
]

Stax, 14 bytes

∞n·Θ3ª&JH‼∙*~Γ

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

VB      constant 256
r       [0 .. 255]
'|*     coerce and string-join with "|"; i.e. "0|1|2|3 ... 254|255"
:{      parenthesize to "(0|1|2|3 ... 254|255)"
]4*     make 4-length array of number pattern
.\.*    string join with "\\."; this forms the complete regex
|Q      is the input a complete match for the regex?

Run this one

Python 3, 109 93 bytes

import re
lambda x:bool(re.match(r'^((25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(\.(?!$)|$)){4}$',x))

Explanation

Each octet can be 0 - 255 :

• starts with 25 and having 0-5 as last digit
• start with 2, has 0-4 as second digit and any digit at the end
• starts with 1, and 00 - 99 as rest digits
• has only 2 digits - 1-9 being the first one and any digit thereafter
• or just a single digit

An octet can end with a (.) or just end, with the condition that it cannot do both , the negative lookahead (?!$) takes care of this case

Thanks @Zachary for making me realize I can discard spaces (since it is code golf)
Thanks @DLosc for the improvements and making me realize my mistake, its been corrected now.

Bash, 30 bytes

ipcalc -c `cat`;echo $(($?^1))

Try it online!

Charcoal, 45 21 bytes

Ｉ∧⁼№θ.³¬Φ⪪θ.¬№Ｅ²⁵⁶Ｉλι

Try it online! Link is to verbose version of code. Edit: Saved 24 bytes by porting @Shaggy's Japt answer. Explanation:

    θ                   Input string
   №                    Count occurrences of
     .                  Literal `.`
  ⁼                     Equal to
      ³                 Literal 3
 ∧                      Logical And
       ¬                Logical Not
          θ             Input string
         ⪪              Split on
           .            Literal `.`
        Φ               Filter by
            ¬           Logical Not
               ²⁵⁶      Literal 256
              Ｅ         Map over implicit range
                   λ    Map value
                  Ｉ     Cast to string
             №          Count occurrences of
                    ι   Filter value
Ｉ                       Cast to string
                        Implicitly print

Retina, 46 44 bytes

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

Port of @OlivierGrégoire's Java answer, so make sure to upvote him!
-2 bytes thanks to @Neil.

Try it online.

Explanation:

^
.                           # Prepend a dot "." before the (implicit) input
^...$                       # Check if the entire string matches the following regex
                            # exactly, resulting in 1/0 as truthy/falsey:
 (                          #  Open a capture group
  \.                        #   A dot "."
    (25[0-5]                #   Followed by a number in the range [250,255]
    |(2[0-4]|         ) \d) #   or by a number in the range [200,249]
    |(      |1\d|     ) \d) #   or by a number in the range [100,199]
    |(          |[1-9]) \d) #   or by a number in the range [10,99]
    |(                )?\d) #   or by a number in the range [0,9]
 )                          #  Close capture group
  {4}                       #  This capture group should match 4 times after each other

Jelly, 11 bytes

⁹ḶṾ€ṗ4j€”.ċ

A monadic link accepting a list of characters which yields $1$ if it's a valid address and $0$ otherwise. Builds a list of all $256^4=4294967296$ addresses and then counts the number of occurrences of the input therein.

Here's similar @ Try it online! that uses $16$ (⁴) rather than $256$ (⁹), since the method is so inefficient!

How?

⁹ḶṾ€ṗ4j€”.ċ - Link: list of characters, S
⁹           - literal 256
 Ḷ          - lowered range = [0,1,2,...,254,255]
  Ṿ€        - unevaluate €ach = ['0','1',...,['2','5','4'],['2','5','5']]
    ṗ4      - 4th Cartesian power = ALL 256^4 lists of 4 of them
            -               (e.g.: ['0',['2','5','5'],'9',['1','0']])
        ”.  - literal '.' character
      j€    - join for €ach (e.g. ['0','.','2','5','5','.','9','.','1','0'] = "0.255.9.10")
          ċ - count occurrences of right (S) in left (that big list)

Retina, 42 41 bytes

~(K`

255*
["^(("|'|]")\.?\b){4}$"L$`
$.`

Try it online! Based on a previous version of @nwellnhof's Perl 6 answer, but 1 byte saved by stealing the \.?\b trick from @Deadcode's answer. Explanation:

K`

Clear the work area.

255*

Insert 255 characters.

["^(("|'|]")\.?\b){4}$"L$`
$.`

Generate the range 0..255 separated with |s, prefixed with ^((, and suffixed with )\.?\b){4}$, thus building the regular expression ^((0|1|...255)\.?\b){4}$.

~(

Evaluate that on the original input.

Pip, 25 16 bytes

a~=X,256RL4J"\."

Takes the candidate IP address as a command-line argument. Try it online! or Verify all test cases

Explanation

Regex solution, essentially a port of recursive's Stax answer.

                  a is 1st cmdline arg (implicit)
    ,256          Range(256), i.e. [0 1 2 ... 255]
   X              To regex: creates a regex that matches any item from that list
                  i.e. essentially `(0|1|2|...|255)`
        RL4       Create a list with 4 copies of that regex
           J"\."  Join on this string
 ~=               Regex full-match
a                 against the input

JavaScript, 89 bytes

(_,r=`(${[...Array(256).keys()].join`|`})`)=>RegExp(`^${(r+'\\.').repeat(3)+r}$`).test(_)

Try it online!

Create RegExp capture groups from indexes of an array having length 256 for range 0-255 joined with | and followed by escaped . character (^(0|1...|255)\.(0|1...|255)\.(0|1...|255)\.(0|1...|255)$) repeated 3 times closing with joined array followed by $ to match end of string, return true or false result of input passed to RegExp.prototype.test().