Standarize ip validation along the code

Details:
 - Use the nova/utils.py validations along the code
 - refactor ipv4 validator to looks like ipv6 validator
 - interprets ip validations exceptions as Invalid IP values

Change-Id: Ia506c00510a066e167d3dcd9dd371a371129a9dd

nova/api/ec2/__init__.py

@@ -442,7 +442,7 @@ class Validator(wsgi.Middleware):
         'image_id': validator.validate_ec2_id,
         'attribute': validator.validate_str(),
         'image_location': validator.validate_image_path,
-        'public_ip': validator.validate_ipv4,
+        'public_ip': utils.is_valid_ipv4,
         'region_name': validator.validate_str(),
         'group_name': validator.validate_str(max_length=255),
         'group_description': validator.validate_str(max_length=255),

nova/api/openstack/compute/contrib/floating_ip_dns.py

@@ -14,7 +14,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License
 
-import socket
 import urllib
 
 import webob
@@ -25,6 +24,7 @@ from nova.api.openstack import xmlutil
 from nova import exception
 from nova import network
 from nova.openstack.common import log as logging
+from nova import utils
 
 
 LOG = logging.getLogger(__name__)
@@ -210,15 +210,8 @@ class FloatingIPDNSEntryController(object):
 
         floating_ip = None
         # Check whether id is a valid ipv4/ipv6 address.
-        try:
+        if utils.is_valid_ipv4(id) or utils.is_valid_ipv6(id):
-            socket.inet_pton(socket.AF_INET, id)
             floating_ip = id
-        except socket.error:
-            try:
-                socket.inet_pton(socket.AF_INET6, id)
-                floating_ip = id
-            except socket.error:
-                pass
 
         if floating_ip:
             entries = self.network_api.get_dns_entries_by_address(context,

nova/api/openstack/compute/servers.py

@@ -17,7 +17,6 @@
 import base64
 import os
 import re
-import socket
 
 from oslo.config import cfg
 import webob
@@ -704,16 +703,12 @@ class Controller(wsgi.Controller):
             raise exc.HTTPBadRequest(explanation=expl)
 
     def _validate_access_ipv4(self, address):
-        try:
+        if not utils.is_valid_ipv4(address):
-            socket.inet_aton(address)
-        except socket.error:
             expl = _('accessIPv4 is not proper IPv4 format')
             raise exc.HTTPBadRequest(explanation=expl)
 
     def _validate_access_ipv6(self, address):
-        try:
+        if not utils.is_valid_ipv6(address):
-            socket.inet_pton(socket.AF_INET6, address)
-        except socket.error:
             expl = _('accessIPv6 is not proper IPv6 format')
             raise exc.HTTPBadRequest(explanation=expl)
 

nova/api/validator.py

@@ -18,7 +18,6 @@
 
 import base64
 import re
-import socket
 
 from nova.openstack.common import log as logging
 
@@ -94,14 +93,6 @@ def validate_image_path(val):
     return True
 
 
-def validate_ipv4(addr):
-    try:
-        socket.inet_aton(addr)
-    except (socket.error, TypeError):
-        return False
-    return True
-
-
 def validate_user_data(user_data):
     """Check if the user_data is encoded properly."""
     try:

nova/tests/api/test_validator.py

@@ -73,14 +73,6 @@ class ValidatorTestCase(test.TestCase):
         self.assertFalse(validator.validate_ec2_id(1234))
         self.assertTrue(validator.validate_ec2_id('i-284f3a41'))
 
-    def test_validate_ipv4(self):
-        self.assertTrue(validator.validate_ipv4('4.2.2.4'))
-        self.assertFalse(validator.validate_ipv4('foobar'))
-        self.assertFalse(
-            validator.validate_ipv4('2001:5a8:4:68e0:e6ce:8fff:fe27:d116'))
-        self.assertFalse(validator.validate_ipv4(123))
-        self.assertFalse(validator.validate_ipv4(''))
-
     def test_validate_url_path(self):
         self.assertTrue(validator.validate_url_path('/path/to/file'))
         self.assertFalse(validator.validate_url_path('path/to/file'))

nova/tests/test_utils.py

@@ -515,6 +515,8 @@ class GenericUtilsTestCase(test.TestCase):
         self.assertTrue(utils.is_valid_ipv4('127.0.0.1'))
         self.assertFalse(utils.is_valid_ipv4('::1'))
         self.assertFalse(utils.is_valid_ipv4('bacon'))
+        self.assertFalse(utils.is_valid_ipv4(""))
+        self.assertFalse(utils.is_valid_ipv4(10))
 
     def test_is_valid_ipv6(self):
         self.assertTrue(utils.is_valid_ipv6("::1"))
@@ -524,6 +526,8 @@ class GenericUtilsTestCase(test.TestCase):
                                     "0000:0000:0000:0000:0000:0000:0000:0001"))
         self.assertFalse(utils.is_valid_ipv6("foo"))
         self.assertFalse(utils.is_valid_ipv6("127.0.0.1"))
+        self.assertFalse(utils.is_valid_ipv6(""))
+        self.assertFalse(utils.is_valid_ipv6(10))
 
     def test_is_valid_ipv6_cidr(self):
         self.assertTrue(utils.is_valid_ipv6_cidr("2600::/64"))

nova/utils.py

@@ -945,14 +945,16 @@ def is_valid_boolstr(val):
 def is_valid_ipv4(address):
     """Verify that address represents a valid IPv4 address."""
     try:
-        addr = netaddr.IPAddress(address)
+        return netaddr.valid_ipv4(address)
-        return addr.version == 4
     except Exception:
         return False
 
 
 def is_valid_ipv6(address):
+    try:
         return netaddr.valid_ipv6(address)
+    except Exception:
+        return False
 
 
 def is_valid_ipv6_cidr(address):