Not a regex, but it works fine for decimal encoded IPs.

sub validIP{ 
    use List::Util qw[ reduce ];
    $a = $b;
    $_[0] =~ m[^[\d\.]+$]
    and 2**32 > reduce{ 
        $a * 256 + ($b < 256 ? $b : 1e99) 
    } reverse split '\.', $_[0]
}
[download]

Here's a different approach specifically for the 4-element dotted form:

  (eval$_)=~/^[\0-\xff]{4}\z/
[download]

This requires perl-5.6.0 or later; extending it for the other forms becomes rather uglier:

  (eval"0.0.$_")=~/^\0\0(.|[\0-\xff]([\0-\x{ffffff}]|[\0-\xff]([\0-\x{
+ffff}]|[\0-\xff]{2})))\z/s
[download]

Of course the usual caveats about eval apply, but this is golf ...

Hugo

To be honest, I don't have the patience to do this manually, right now. A much more interesting problem would be writing a somewhat generic algorithm to create such regexes. I posted a regex generator for a closely related problem to the fun-with-perl list a while ago. Since adapting it to your question would take more fiddling than I currently have the stamina for, I'll simply outline the structure of the resulting regex (written in /x syntax for the purposes of this post):

0*
    (?:
        1\d?
        |
        2 (?:
            [0-4]\d?
            | 
            5[0-5]?
        )
    )
    (?:
        (?:
            # since we got here, the first 1-3 digits formed a number 
+< 256
            # so allow a dot
            \.
            # a near-copy of the surrounding regex goes here to match 
+next octet
        )
        |
        # no dot matched: allow digit-only strings forming numbers up 
+to 2**32-1
        # (and remember we might already have matched up to 3 digits!)
        # this bit needs adjusting to smaller ranges in the nested cop
+ies
    )
[download]

You can see that it's highly formulaic.

It might make an interesting project to generalize a few numeral-matching pattern builders sufficiently to make them into a module (if such a thing doesn't already exist). I've built such regexen by hand often enough that I've gotten thoroughly sick of doing it; it's a nearly trivial but mind numbingly tedious task.

For some interesting reading on this topic, you should probably check out the Don't Use Regular Expressions To Parse IP Addresses! node. It's quite detailed and informative.