A proper solution to your stated need is to use the inet_aton and inet_ntoa functions provided by the Socket module, which is part of the standard library.

inet_aton translates any valid IP address -- regardless of notation format -- or domain name into a packed string containing the 32-bit integer. Such a string can be converted into a dotted-quad representation by the inet_ntoa function.

Example:

    use Socket; # load inet_aton, inet_ntoa

    $_ = <>; # read user's input
    chomp;

    # convert to packed string.  succeeds if valid address.
    my $ip = inet_aton( $_ );

    # length will be 4 for IPv4 addresses.
    length($ip) or die "Sorry, '$_' is invalid.\n";

    $ip = inet_ntoa($ip); # convert to dotted quad.

    print "$_ is valid; its IP address is $ip\n";
[download]

This is a variation of one from the the Great Book "Mastering Regular Expressions" by Jeffrey Friedl,
which I highly recommend.

unless
(
    $ip =~ m/^(?:[1]?\d\d?|2[0-4]\d|25[0-5])\.
              (?:[1]?\d\d?|2[0-4]\d|25[0-5])\.
              (?:[1]?\d\d?|2[0-4]\d|25[0-5])\.
              (?:[1]?\d\d?|2[0-4]\d|25[0-5])$
            /x
)
{
    # do something
}
[download]

which you can handle easily by one addtional check to your test routine.

if ( $ip =~ /^0.0.0.0$/ )
{
    # do something
}
[download]

Your pattern does match 0.0.0.0 from what I can tell. And this slight change makes it robust against arbitrary prefix zeros to boot.

/^
   0*?(?:1?\d\d?|2[0-4]\d|25[0-5])\.
   0*?(?:1?\d\d?|2[0-4]\d|25[0-5])\.
   0*?(?:1?\d\d?|2[0-4]\d|25[0-5])\.
   0*?(?:1?\d\d?|2[0-4]\d|25[0-5])
$/x;
[download]

--- demerphq
my friends call me, usually because I'm late....

0.0.0.0

is not actually a valid IP address. Which is why I mentioned that my pattern did not catch this (as invalid that is). The pattern matches it, but it should not. :-)

Leading 0's in an IP are also considered to be invalid.

1.003.003.123 is invalid and should be expressed without leading 0's

Best Regards,
Wonko

use NetAddr::IP;

if (defined NetAddr::IP->new($myip)) {
   ... Your code goes here ...
}
else {
  die "Do not feed me with garbage!\n";
}
[download]

You can download the module from here or any friendly CPAN mirror.

Disclaimer: I wrote NetAddr::IP so I might be a bit biased :) Best regards

-lem, but some call me fokat

10. 22.   109 934324 23832 23.104
200. 12.21.3
0.^^&7".34.55-1
[download]

while ( <DATA> ) {
    chomp;
    print $_, ": ", check_ip( $_ ), "\n";
}


sub check_ip {

    my ( $ip ) = @_;
    return "Wrong format" unless $ip =~ /^(\d{1,3}\.){3}\d{1,3}$/;
    return "Illegal value" if grep { $_ > 255 } split /\./, $ip;
    return "Weird zeroes" if grep { /^0[0-9]/ } split /\./, $ip;
    return "OK"
}

__DATA__
0.^^&7".34.55-1
fda.er32.223.1
10.00.120.13
32.294.233.12
-02.35.54.54
41.41.22.50
[download]

I don't like the regexp approach for this type of problems, I find it easier to dissect things one by one...

#!/usr/local/bin/perl
use strict;

sub ipverify
{
    my( $ip ) = @_;

    if($ip =~ /[^\d.]/) {
        die "Found illegal characters in ip: $ip";
    }
    my @octets = split( /\./, $ip );
    if(@octets != 4) {
        die "number of octets must be 4";
    }

    foreach my $octet (@octets) {
        ## numerical sanity
        if($octet < 0 || $octet > 255) {
            die "octet $octet is out of range ( 0 <= x <= 255 )";
        }

        ## $octet should not start with a 0 if it evaluates to
        ## less than 100
        if( $octet < 100 ) {
            ## if 0, octet should be single digit
            if($octet == 0 && length($octet) != 1) {
                die "bad representation '$octet'. rewrite as '0'";
            }
            if($octet =~ /^0+(\d+)$/) {
                die "bad representation '$octet'. rewrite as '$1'";
            }
        }
    }
    return 1;
}

sub hostname_verify
{
    my($hostname) = @_;
    my $iaddr = gethostbyname($hostname);
    if(!$iaddr) {
        die "Hostname '$hostname' did not resolve";
    }
    return 1;
}

sub main
{   
    while(1) {
        print "Type in IP address or hostname to verify (enter to quit
+): ";

        chomp(my $input = <STDIN>);
        if(!length($input)) {
            last;
        }

        if($input =~ /\D/) {
            eval{ hostname_verify($input) };
        } else {
            eval{ ip_verify($input) };
        }
        if($@) {
            (my $err = $@) =~ s/ at .*$//;
            print STDERR "   ERROR: $err\n";
        } else {
            print "$input is a valid address\n";
        }
    }
}

main();
[download]

The test for an octet < 0 is not necessary, since a negative number won't get past the initial regex test.