fields.py 10.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# Copyright 2014 Budapest University of Technology and Economics (BME IK)
#
# This file is part of CIRCLE Cloud.
#
# CIRCLE is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along
# with CIRCLE.  If not, see <http://www.gnu.org/licenses/>.

18 19 20 21 22
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.utils.ipv6 import is_valid_ipv6_address
from south.modelsinspector import add_introspection_rules
23
from django import forms
24 25
from netaddr import (IPAddress, IPNetwork, AddrFormatError, ZEROFILL,
                     EUI, mac_unix)
26 27
import re

28 29

mac_re = re.compile(r'^([0-9a-fA-F]{2}(:|$)){6}$')
30 31
alfanum_re = re.compile(r'^[A-Za-z0-9_-]+$')
domain_re = re.compile(r'^([A-Za-z0-9_-]\.?)+$')
32
ipv4_re = re.compile('^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$')
33
reverse_domain_re = re.compile(r'^(%\([abcd]\)d|[a-z0-9.-])+$')
34
ipv6_template_re = re.compile(r'^(%\([abcd]\)[dxX]|[A-Za-z0-9:-])+$')
35

36

37
class MACAddressFormField(forms.Field):
38 39 40 41
    default_error_messages = {
        'invalid': _(u'Enter a valid MAC address.'),
    }

42 43 44 45 46 47
    def validate(self, value):
        try:
            return EUI.from_str(value)
        except (AddrFormatError, TypeError), e:
            raise ValidationError(self.default_error_messages['invalid']
                                  % unicode(e))
48

49

50
class MACAddressField(models.Field):
51 52 53 54 55
    description = _('MAC Address object')
    __metaclass__ = models.SubfieldBase

    class mac_custom(mac_unix):
        word_fmt = '%.2X'
56

57 58 59 60
    def __init__(self, *args, **kwargs):
        kwargs['max_length'] = 17
        super(MACAddressField, self).__init__(*args, **kwargs)

61 62 63 64 65 66 67 68 69 70
    @staticmethod
    def from_str(value):
        if not value or value == "":
            return None

        if isinstance(value, EUI):
            return value

        return EUI(value, dialect=MACAddressField.mac_custom)

71 72 73
    def get_internal_type(self):
        return 'CharField'

74
    def to_python(self, value):
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
        return MACAddressField.from_str(value)

    def get_db_prep_value(self, value, connection, prepared=False):
        if not value or value == "":
            return None

        if isinstance(value, EUI):
            return str(value)
        return value

    def value_to_string(self, obj):
        value = self._get_val_from_obj(obj)
        return str(self.get_prep_value(value))

    def clean(self, value, model_instance):
        value = super(MACAddressField, self).clean(value, model_instance)
        return self.get_prep_value(value)
92

93 94 95 96
    def formfield(self, **kwargs):
        defaults = {'form_class': MACAddressFormField}
        defaults.update(kwargs)
        return super(MACAddressField, self).formfield(**defaults)
97

98 99
add_introspection_rules([], ["firewall\.fields\.MACAddressField"])

100

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
class IPAddressFormField(forms.Field):
    default_error_messages = {
        'invalid': _(u'Enter a valid IP address. %s'),
    }

    def validate(self, value):
        try:
            return IPAddressField.from_str(value, version=self.version)
        except (AddrFormatError, TypeError), e:
            raise ValidationError(self.default_error_messages['invalid']
                                  % unicode(e))

    def __init__(self, *args, **kwargs):
        self.version = kwargs['version']
        del kwargs['version']
        super(IPAddressFormField, self).__init__(*args, **kwargs)


class IPAddressField(models.Field):
    description = _('IP Network object')
    __metaclass__ = models.SubfieldBase

    def __init__(self, version=4, serialize=True, *args, **kwargs):
        kwargs['max_length'] = 100
        self.version = version
        super(IPAddressField, self).__init__(*args, **kwargs)

    @staticmethod
    def from_str(value, version):
        if not value or value == "":
            return None

        if isinstance(value, IPAddress):
            return value

136 137
        return IPAddress(value.split('/')[0], version=version,
                         flags=ZEROFILL)
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170

    def get_internal_type(self):
        return "CharField"

    def to_python(self, value):
        return IPAddressField.from_str(value, self.version)

    def get_db_prep_value(self, value, connection, prepared=False):
        if not value or value == "":
            return None

        if isinstance(value, IPAddress):
            if self.version == 4:
                return ('.'.join(["%03d" % x for x in value.words]))
            else:
                return (':'.join(["%04X" % x for x in value.words]))
        return value

    def value_to_string(self, obj):
        value = self._get_val_from_obj(obj)
        return str(self.get_prep_value(value))

    def clean(self, value, model_instance):
        value = super(IPAddressField, self).clean(value, model_instance)
        return self.get_prep_value(value)

    def formfield(self, **kwargs):
        defaults = {'form_class': IPAddressFormField}
        defaults['version'] = self.version
        defaults.update(kwargs)
        return super(IPAddressField, self).formfield(**defaults)


171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
class IPNetworkFormField(forms.Field):
    default_error_messages = {
        'invalid': _(u'Enter a valid IP network. %s'),
    }

    def validate(self, value):
        try:
            return IPNetworkField.from_str(value, version=self.version)
        except (AddrFormatError, TypeError), e:
            raise ValidationError(self.default_error_messages['invalid']
                                  % unicode(e))

    def __init__(self, *args, **kwargs):
        self.version = kwargs['version']
        del kwargs['version']
        super(IPNetworkFormField, self).__init__(*args, **kwargs)


class IPNetworkField(models.Field):
    description = _('IP Network object')
    __metaclass__ = models.SubfieldBase

193
    def __init__(self, version=4, serialize=True, *args, **kwargs):
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
        kwargs['max_length'] = 100
        self.version = version
        super(IPNetworkField, self).__init__(*args, **kwargs)

    @staticmethod
    def from_str(value, version):
        if not value or value == "":
            return None

        if isinstance(value, IPNetwork):
            return value

        return IPNetwork(value, version=version)

    def get_internal_type(self):
        return "CharField"

    def to_python(self, value):
        return IPNetworkField.from_str(value, self.version)

    def get_db_prep_value(self, value, connection, prepared=False):
        if not value or value == "":
            return None

        if isinstance(value, IPNetwork):
            if self.version == 4:
220 221
                return ('.'.join(["%03d" % x for x in value.ip.words])
                        + '/%02d' % value.prefixlen)
222
            else:
223 224
                return (':'.join(["%04X" % x for x in value.ip.words])
                        + '/%03d' % value.prefixlen)
225 226 227 228
        return value

    def value_to_string(self, obj):
        value = self._get_val_from_obj(obj)
229
        return str(self.get_prep_value(value))
230 231 232 233 234 235 236 237 238 239 240

    def clean(self, value, model_instance):
        value = super(IPNetworkField, self).clean(value, model_instance)
        return self.get_prep_value(value)

    def formfield(self, **kwargs):
        defaults = {'form_class': IPNetworkFormField}
        defaults['version'] = self.version
        defaults.update(kwargs)
        return super(IPNetworkField, self).formfield(**defaults)

241
add_introspection_rules([], ["^firewall\.fields\.IP(Address|Network)Field"])
242 243


244 245 246 247
def val_alfanum(value):
    """Validate whether the parameter is a valid alphanumeric value."""
    if not alfanum_re.match(value):
        raise ValidationError(_(u'%s - only letters, numbers, underscores '
248 249
                                'and hyphens are allowed!') % value)

250 251 252 253 254

def is_valid_domain(value):
    """Check whether the parameter is a valid domain name."""
    return domain_re.match(value) is not None

255

256 257 258 259 260
def val_domain(value):
    """Validate whether the parameter is a valid domin name."""
    if not is_valid_domain(value):
        raise ValidationError(_(u'%s - invalid domain name') % value)

261

262 263 264 265
def is_valid_reverse_domain(value):
    """Check whether the parameter is a valid reverse domain name."""
    return reverse_domain_re.match(value) is not None

266

267 268 269 270 271
def val_reverse_domain(value):
    """Validate whether the parameter is a valid reverse domain name."""
    if not is_valid_reverse_domain(value):
        raise ValidationError(u'%s - invalid reverse domain name' % value)

272

273 274 275 276 277 278 279 280 281 282 283
def is_valid_ipv6_template(value):
    """Check whether the parameter is a valid ipv6 template."""
    return ipv6_template_re.match(value) is not None


def val_ipv6_template(value):
    """Validate whether the parameter is a valid ipv6 template."""
    if not is_valid_ipv6_template(value):
        raise ValidationError(u'%s - invalid reverse ipv6 template' % value)


284 285 286 287
def is_valid_ipv4_address(value):
    """Check whether the parameter is a valid IPv4 address."""
    return ipv4_re.match(value) is not None

288

289 290 291 292 293
def val_ipv4(value):
    """Validate whether the parameter is a valid IPv4 address."""
    if not is_valid_ipv4_address(value):
        raise ValidationError(_(u'%s - not an IPv4 address') % value)

294

295 296 297 298 299
def val_ipv6(value):
    """Validate whether the parameter is a valid IPv6 address."""
    if not is_valid_ipv6_address(value):
        raise ValidationError(_(u'%s - not an IPv6 address') % value)

300 301 302 303 304 305 306 307 308 309 310 311 312

def val_mx(value):
    """Validate whether the parameter is a valid MX address definition.

    Expected form is <priority>:<hostname>.
    """
    mx = value.split(':', 1)
    if not (len(mx) == 2 and mx[0].isdigit() and
            domain_re.match(mx[1])):
        raise ValidationError(_("Bad MX address format. "
                                "Should be: <priority>:<hostname>"))


313
def convert_ipv4_to_ipv6(ipv6_template, ipv4):
314
    """Convert IPv4 address string to IPv6 address string."""
315 316 317 318 319
    m = ipv4.words
    return IPAddress(ipv6_template % {'a': int(m[0]),
                                      'b': int(m[1]),
                                      'c': int(m[2]),
                                      'd': int(m[3])})