def get(self, request): try: input1 = request.GET.get("input1") input2 = request.GET.get("input2") validate_ipv4_address(input1) validate_ipv4_address(input2) first = ipaddress.IPv4Address(input1) last = ipaddress.IPv4Address(input2) queryset = Router.objects.filter(is_active=True) summary = " ".join(map(str, ipaddress.summarize_address_range(first, last))) final_data = [] for i in queryset: if ipaddress.IPv4Network(i.loopback).__str__() in summary: final_data.append(i) data = RouterSerializer(final_data, many=True) return Response({"data": data.data, "success": True}, status=200) except ValueError as error: traceback.print_exc() return Response({"error": error, "success": False}, status=400) except ValidationError as error: traceback.print_exc() return Response({"error": error, "success": False}, status=400) except Exception as error: traceback.print_exc() return Response({"error": str(error), "success": False}, status=400)
def create_or_view_network_tool(request): if request.method == "POST": rtype = request.POST['type'] ip = request.POST['ip'] is_url = False try: try: validators.validate_ipv4_address(ip) # ip format x.x.x.x except ValidationError, error: # url format www.xxx.xxx value = ip if not '://' in value: value = 'https://%s' % value urlvalidator = validators.URLValidator() urlvalidator(value) is_url = True if rtype == "ping": rcode, output = networkutils.ping(ip) elif rtype == "traceroute": rcode, output = networkutils.traceroute(ip) elif rtype == "nslookup": try: if is_url: output = networkutils.resolve_name(ip) else: output = networkutils.resolve_addr(ip) except (networkutils.HostAddrNotFound, networkutils.HostNameNotFound), error: output = "Não encontrado"
def to_python(self, value): if not value: return None if isinstance(value, IPAddress): return value # netaddr is a bit too liberal with what it accepts as a valid IP address. For example, '1.2.3' will become # IPAddress('1.2.0.3'). Here, we employ Django's built-in IPv4 and IPv6 address validators as a sanity check. try: validate_ipv4_address(value) except ValidationError: try: validate_ipv6_address(value) except ValidationError: raise ValidationError( "Invalid IPv4/IPv6 address format: {}".format(value)) try: return IPAddress(value) except ValueError: raise ValidationError( 'This field requires an IP address without a mask.') except AddrFormatError: raise ValidationError( "Please specify a valid IPv4 or IPv6 address.")
def validate_ipv4_range(value): try: ip, offset = value.split('#') validate_ipv4_address(ip) int(offset) except: raise ValidationError('Range %s has not a valid format (IPv4#N).' % value)
def update(request, id): router = Router.objects.get(pk=id) if request.method == 'POST': sapid = request.POST['sapid'] host = request.POST['host'] loop = request.POST['loop'] mac = request.POST['mac'] try: validate_ipv4_address(loop) # Success except ValidationError: data = {'message': 'Invalid Loopback !!!'} return HttpResponse( json.dumps(data), content_type='application/json') if not is_valid_macaddr802(mac): data = {'message': 'Invalid Mac Address !!!'} return HttpResponse( json.dumps(data), content_type='application/json') router.sapId = sapid router.hostname = host router.loopback = loop router.macAddress = mac router.save() data = {'message': 'Success'} return HttpResponse( json.dumps(data), content_type='application/json') context = { 'router': router } return render(request, 'update.html', context)
def create(request): if request.method == 'POST': sapid = request.POST['sapid'] host = request.POST['host'] loop = request.POST['loop'] mac = request.POST['mac'] try: validate_ipv4_address(loop) # Success except ValidationError: data = {'message': 'Invalid Loopback !!!'} return HttpResponse( json.dumps(data), content_type='application/json') if not is_valid_macaddr802(mac): data = {'message': 'Invalid Mac Address !!!'} return HttpResponse( json.dumps(data), content_type='application/json') route = Router.objects.create( sapId=sapid, hostname=host, loopback=loop, macAddress=mac) route.save() data = {'message': 'Success'} return HttpResponse( json.dumps(data), content_type='application/json') return render(request, 'create.html')
def validate_ip_bool(address): try: validate_ipv4_address(address) return True except ValidationError: return False
def ip_or_none(ip): """Return IP address if it is valide, None otherwise""" try: validate_ipv4_address(ip) return ip except ValidationError: return None
def get_ip(request): """ Retrieves the remote IP address from the request data. If the user is behind a proxy, they may have a comma-separated list of IP addresses, so we need to account for that. In such a case, only the first IP in the list will be retrieved. Also, some hosts that use a proxy will put the REMOTE_ADDR into HTTP_X_FORWARDED_FOR. This will handle pulling back the IP from the proper place. **NOTE** This function was taken from django-tracking (MIT LICENSE) http://code.google.com/p/django-tracking/ """ # if neither header contain a value, just use local loopback ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META.get("REMOTE_ADDR", "127.0.0.1")) if ip_address: # make sure we have one and only one IP try: validate_ipv4_address(ip_address) except ValidationError: try: validate_ipv6_address(ip_address) except ValidationError: ip_address = "10.0.0.1" else: ip_address = "10.0.0.1" return ip_address
def validate(self): if not isinstance(self.config, dict): logger.error('unexcepted config format') raise TypeError('configuration type error. expected dict, got {err_}'.format(err_=type(self.config))) for field in self.fields: valid = True value = self.config['server']['conf'][field[0]] if value: if field[0] == 'server_ip' and value not in self.domain_whitelist: try: validate_ipv4_address(value) except ValidationError: valid = False elif field[0] == 'server_domain' and value not in self.domain_whitelist: url_validator = URLValidator() try: url_validator(value) except ValidationError: valid = False elif (field[0] == 'server_type' and value not in self.server_types) or ( field[0] == 'emu_type' and value not in self.emu_types): valid = False else: if not isinstance(value, field[1]) or (field[2] > 0 and len(value) < field[2]): valid = False if not valid: self.config['server']['conf'][field[0]] = field[3] logger.warn(self.message.format(field=field[0], default=field[3])) self.errors.append(self.message.format(field=field[0], default=field[3]))
def clean(self): cleaned_data = super(OpenVASForm, self).clean() urls = cleaned_data.get("urls") ips = cleaned_data.get("ips") config = cleaned_data.get("config") print(ips) if (config == "Full and fast ultimate" or config == "Full and very deep ultimate") and ( not can_ultimate(self.user)): raise forms.ValidationError( _("You are not allowed to scan in Ultimate mode, please contact your administrator if you need this permission. " )) if urls == "" and ips == "": raise forms.ValidationError( _("Please specify at least 1 target, by URL, by IP or both")) if (ips is not None): ip = ips.replace(" ", "").split(",") for i in ip: if i != "": try: validate_ipv4_address(i) except: if not can_network(self.user): raise ValidationError( _((my_default_errors_IP['network'])))
def validate_and_normalize_ip(ip_address, ip_type): """ Validate and normalize the given IP address :param ip_address: the IP address to validate and normalize :type ip_address: str :param ip_type: the type of the IP address :type ip_type: str :returns: tuple: (Valid normalized IP, Error message) """ cleaned = None if ip_type in (IPTypes.IPV4_SUBNET, IPTypes.IPV6_SUBNET): try: if '/' not in ip_address: raise ValidationError("") cidr_parts = ip_address.split('/') if int(cidr_parts[1]) < 0 or int(cidr_parts[1]) > 128: raise ValidationError("") if ':' not in cidr_parts[0] and int(cidr_parts[1]) > 32: raise ValidationError("") ip_address = cidr_parts[0] except (ValidationError, ValueError): return ("", "Invalid CIDR address") if ip_type in (IPTypes.IPV4_ADDRESS, IPTypes.IPV4_SUBNET): try: validate_ipv4_address(ip_address) # Remove leading zeros cleaned = [] for octet in ip_address.split('.'): cleaned.append(octet.lstrip('0') or '0') cleaned = '.'.join(cleaned) except ValidationError: if ip_type == IPTypes.IPV4_ADDRESS: return ("", "Invalid IPv4 address") else: return ("", "Invalid IPv4 CIDR address") if ip_type in (IPTypes.IPV6_ADDRESS, IPTypes.IPV6_SUBNET): try: validate_ipv6_address(ip_address) # Replaces the longest continuous zero-sequence with "::" and # removes leading zeroes and makes sure all hextets are lowercase. cleaned = clean_ipv6_address(ip_address) except ValidationError: if ip_type == IPTypes.IPV6_ADDRESS: return ("", "Invalid IPv6 address") else: return ("", "Invalid IPv6 CIDR address") if not cleaned: return ("", "Invalid IP type.") elif ip_type in (IPTypes.IPV4_SUBNET, IPTypes.IPV6_SUBNET): return (cleaned + '/' + cidr_parts[1], "") else: return (cleaned, "")
def validate_and_normalize_ip(ip_address, ip_type): """ Validate and normalize the given IP address :param ip_address: the IP address to validate and normalize :type ip_address: str :param ip_type: the type of the IP address :type ip_type: str :returns: tuple: (Valid normalized IP, Error message) """ cleaned = None if "cidr" in ip_type: try: if "/" not in ip_address: raise ValidationError("") cidr_parts = ip_address.split("/") if int(cidr_parts[1]) < 0 or int(cidr_parts[1]) > 128: raise ValidationError("") if ":" not in cidr_parts[0] and int(cidr_parts[1]) > 32: raise ValidationError("") ip_address = cidr_parts[0] except (ValidationError, ValueError): return ("", "Invalid CIDR address") if "Address - ipv4" in ip_type or "cidr" in ip_type: try: validate_ipv4_address(ip_address) # Remove leading zeros cleaned = [] for octet in ip_address.split("."): cleaned.append(octet.lstrip("0") or "0") cleaned = ".".join(cleaned) except ValidationError: if "cidr" not in ip_type: return ("", "Invalid IPv4 address") else: ip_type = "cidr_ipv6" if "Address - ipv6" in ip_type or ip_type == "cidr_ipv6": try: validate_ipv6_address(ip_address) # Replaces the longest continuous zero-sequence with "::" and # removes leading zeroes and makes sure all hextets are lowercase. cleaned = clean_ipv6_address(ip_address) except ValidationError: if "cidr" in ip_type: return ("", "Invalid CIDR address") else: return ("", "Invalid IPv6 address") if not cleaned: return ("", "Invalid IP type.") elif "cidr" in ip_type: return (cleaned + "/" + cidr_parts[1], "") else: return (cleaned, "")
def ip_validator(ip): try: validate_ipv4_address(ip) except ValidationError: try: validate_ipv6_address(ip) except ValidationError: raise ValidationError('Invalid IP address')
def clean_controller_ip(self): controller_ip = None if "controller_ip" in self.cleaned_data: controller_ip = self.cleaned_data["controller_ip"] # Optional field. May not be there if controller_ip: validators.validate_ipv4_address(controller_ip) return controller_ip
def validate(self, value): "Check if value consists only of valid ipaddress." # Use the parent's handling of required fields, etc. super(MultiIpaddressField, self).validate(value) for ip in value: validate_ipv4_address(ip)
def perform_checking(ip): django_validator.validate_ipv4_address(ip) if not self.existing_subnet: raise forms.ValidationError(_("Cannot get allowed subnet for the environment, " "consult your admin")) elif not netaddr.IPAddress(ip) in netaddr.IPNetwork(self.existing_subnet): raise forms.ValidationError( _("Specified IP address should belong to {0} " "subnet").format(self.existing_subnet) )
def clean_content(self): """Clean content based on selected type""" data = self.cleaned_data.get('content') _type = self.cleaned_data.get('type') if _type == 'A': validate_ipv4_address(data) elif _type == 'AAAA': validate_ipv6_address(data) return data
def validate_freeswitch_ipaddress(value): try: validate_ipv4_address(value) except ValidationError, e: try: validate_freeswitch_variable(value) except ValidationError: raise ValidationError(_(u'Enter a valid IPv4 address, ' 'or a FreeSWITCH variable.'))
def should_give_doge(request, send_addr=None): ip = get_ip(request) validate_ipv4_address(ip) week_ago = datetime.utcnow().replace(tzinfo=utc) - timedelta(days=7) query = Q(ip_address=ip) if send_addr: query = query | Q(sent_address=send_addr) transactions = Transaction.objects.filter(query).filter(tx_time__gt=week_ago) return len(transactions) == 0
def clean_content(self): """Ensures that content is an IPv4 address.""" content = self.cleaned_data.get('content') try: validate_ipv4_address(content) except ValidationError: raise forms.ValidationError("""Content should contain an IPv4 address""") else: return content
def get_object(self): ip_address = self.request.query_params.get('ip', None) try: validate_ipv4_address(ip_address) except ValidationError: raise Http404() obj = get_object_or_404(GeoLocationData, ip=ip_address) return obj
def validate_hostname(val): try: validate_ipv4_address(val) except ValidationError: # ip may in fact be a hostname # http://www.regextester.com/23 HOSTNAME_RX = r'^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$' if not re.match(HOSTNAME_RX, val): raise ValidationError('Invalid hostname or IP')
def clean_value(self, value, operator_slug, request): if value is None: return value elif operator_slug not in {OPERATORS.CONTAINS, OPERATORS.EXACT, OPERATORS.STARTSWITH, OPERATORS.ENDSWITH}: try: validate_ipv4_address(value) except ValidationError: raise FilterValueError(ugettext('Value must be in format IPv4.')) return value
def getClientAdress( request ): ip = request.get_host() try: validate_ipv4_address( ip ) except ValidationError: ip = '' return ip
def inner(value): try: validate_ipv4_address(value) except ValidationError: try: validate_ipv6_address(value) except ValidationError: raise argparse.ArgumentTypeError( 'Enter a valid IPv4 or IPv6 address') return value
def process_request(self, request): if request.user.is_authenticated(): ip = request.META.get('REMOTE_ADDR', '') try: validate_ipv4_address(ip) if request.user.last_ip != ip: request.user.last_ip = ip request.user.save() except ValidationError: pass
def clean_content_field(self): """Perform a type-dependent validation of content field""" if self.type == "A": validate_ipv4_address(self.content) elif self.type == "AAAA": validate_ipv6_address(self.content) elif self.type == "SOA": validate_soa(self.content) elif self.type in DOMAIN_NAME_RECORDS: validate_domain_name(self.content)
def perform_checking(ip): validate_ipv4_address(ip) if not self.existing_subnet: raise forms.ValidationError( _('Cannot get allowed subnet for the environment, ' 'consult your admin')) elif not IPAddress(ip) in IPNetwork(self.existing_subnet): raise forms.ValidationError( _('Specified IP address should belong to {0} ' 'subnet'.format(self.existing_subnet)))
def clean_content_field(self): """Perform a type-dependent validation of content field""" if self.type == 'A': validate_ipv4_address(self.content) elif self.type == 'AAAA': validate_ipv6_address(self.content) elif self.type == 'SOA': validate_soa(self.content) elif self.type in DOMAIN_NAME_RECORDS: validate_domain_name(self.content)
def getClientAdress(request): ip = request.get_host() try: validate_ipv4_address(ip) except ValidationError: ip = '' return ip
def validate_ipv46_address(self, value): from django.core.validators import validate_ipv4_address, validate_ipv6_address try: validate_ipv4_address(value) return 'ipv4' except ValidationError: try: validate_ipv6_address(value) return 'ipv6' except ValidationError: raise ValidationError(_('Enter a valid IPv4 or IPv6 address.'), code='invalid')
def process_request(self, request): host = request.get_host() domain, port = split_domain_port(host) try: validate_ipv4_address(domain) except ValidationError: # not an IP address. Call the superclass return super(EnforceHostIPMiddleware, self).process_request(request) # it is an IP address return
def validate_ip(value): try: validate_ipv4_address(value) except: raise ValidationError(_(my_default_errors_IP['invalid'])) else: b = False for d in valid_domains: if value in IPNetwork(d): b = True if not b: raise ValidationError(_(my_default_errors_IP['domain']))
def clean_value(self, value, operator_slug, request): if value is None: return value elif operator_slug not in { OPERATORS.CONTAINS, OPERATORS.EXACT, OPERATORS.STARTSWITH, OPERATORS.ENDSWITH }: try: validate_ipv4_address(value) except ValidationError: raise FilterValueError( ugettext('Value must be in format IPv4.')) return value
def test_filling_IPAddressField(self): obj = baker.make(models.DummyGenericIPAddressFieldModel) field = models.DummyGenericIPAddressFieldModel._meta.get_field('ipv4_field') assert isinstance(field, fields.GenericIPAddressField) assert isinstance(obj.ipv4_field, str) validate_ipv4_address(obj.ipv4_field) if hasattr(obj, 'ipv6_field'): assert isinstance(obj.ipv6_field, str) assert isinstance(obj.ipv46_field, str) validate_ipv6_address(obj.ipv6_field) validate_ipv46_address(obj.ipv46_field)
def modify_client(request, client_id): user_client = request.user.my_userprofile.client if not user_client: raise Exception(u"Pas de client dans le profil pour l'utilisateur %s." % request.user) client = get_object_or_404(Client, pk=client_id) if not user_has_perms_on_client(request.user, client): raise PermissionDenied coordinate = client.coordinates or Coordinate() if request.method == "POST": client_form = ClientForm(request.POST, instance=client) coordinate_form = CoordinateForm(request.POST, instance=coordinate) if coordinate_form.is_valid() and client_form.is_valid(): inst = coordinate_form.save() client.coordinates = inst client_form.save() #return redirect(reverse("common.views.modify_client")) else: client_form = ClientForm(instance=client) coordinate_form = CoordinateForm(instance=coordinate) # list hosts current client can see host_list = HostChar.objects.filter(client=client_id) ip_table = [] for host in host_list: host_ip = host.host.ip.split() for ip in host_ip: try: validators.validate_ipv4_address(ip) ip_table.append([host.id, host.host, ip, host.host.type, host.host.id, host.name]) except ValidationError: pass host_list_configure = ip_table host_list_qs = Host.objects.filter_by_user(request.user) host_list_qs = host_list_qs.filter(site__in=Client.objects.get_childs('parent', client.id)) return render_to_response("common/client/modify.html", { "client": client, "client_form": client_form, "coordinate_form": coordinate_form, "host_list_qs": host_list_qs, "host_list_configure": host_list_configure, }, context_instance=RequestContext(request))
def clean(self): cleaned_data = super(EditRecordForm, self).clean() name = cleaned_data.get('name') domain = Domain.objects.get(id=cleaned_data.get('domain')) type = cleaned_data.get('type') content = cleaned_data.get('content') mac = cleaned_data.get('mac') #fix a bug where validate_ipv6_address cannot process NoneType #So instead of passing None we pass 1 witch is invalid as well if content == None: content = '1' if type == 'A' or type == 'AAAA': ip_valid = True else: ip_valid = False if type == 'A': try: validate_ipv4_address(content) except ValidationError: self.errors['content'] = self.error_class(['Not an IPv4 address']) ip_valid = False except AddrFormatError: self.errors['content'] = self.error_class(['Not an IPv4 address']) ip_valid = False if type == 'AAAA' and ip_valid: try: validate_ipv6_address(content) except ValidationError: self.errors['content'] = self.error_class(['Not an IPv6 address']) ip_valid = False ranges = Range.objects.all() found = False if ip_valid: for range in ranges: if IPAddress(content) >= IPNetwork(range.cidr).network and IPAddress(content) <= IPNetwork(range.cidr).broadcast: found = True break if mac: if not re.match("[0-9a-f]{2}([\.\-:])[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", mac.lower()): self.errors['mac'] = self.error_class(['Not a MAC address']) del cleaned_data['mac'] m = re.sub("[.:-]", "", mac) m = m.lower() mac = "%s-%s-%s-%s-%s-%s" % (m[0:2], m[2:4], m[4:6], m[6:8], m[8:10], m[10:]) cleaned_data['mac'] = mac if not found and ip_valid: self.errors['content'] = self.error_class(['IP is not within a known range']) ip_valid = False return cleaned_data
def perform_checking(ip): validate_ipv4_address(ip) if not all_matching_cidrs(ip, ip_ranges) and ip_ranges: raise forms.ValidationError(_('Specified Cluster Static IP is' 'not in valid IP range')) try: ip_info = novaclient(request).fixed_ips.get(ip) except exceptions.UNAUTHORIZED: exceptions.handle( request, _("Unable to retrieve information " "about fixed IP or IP is not valid."), ignore=True) else: if ip_info.hostname: raise forms.ValidationError( _('Specified Cluster Static IP is already in use'))
def ip_to_long(value): validators.validate_ipv4_address(value) lower_validator = validators.MinValueValidator(0) upper_validator = validators.MinValueValidator(255) value = value.split('.') output = 0 for i in range(0, 4): validators.validate_integer(value[i]) lower_validator(value[i]) upper_validator(value[i]) output += long(value[i]) * (256**(3-i)) return output
def validate_proxy(val): if val.count(':') != 1: raise ValidationError('Invalid address') host, port = val.split(':') try: validate_ipv4_address(host) except ValidationError: # ip may in fact be a hostname # http://www.regextester.com/23 HOSTNAME_RX = r'^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$' if not re.match(HOSTNAME_RX, host): raise ValidationError('Invalid hostname or IP') try: port = int(port) except ValueError: raise ValidationError('Invalid port')
def clean(self, value): if (value in ADDRESS_CONSTANTS or validate_ipv4_address(value) or stun_re.match(value)): return value else: raise forms.ValidationError( "This field must be set to an IP address, STUN address " "(e.g. stun:stun.freeswitch.org) or \"auto\"/\"auto-nat\".")
def get_ip_address_from_request(request): """ Makes the best attempt to get the client's real IP or return the loopback """ # Would rather rely on middleware to set up a good REMOTE_ADDR than try to get # fancy here. Also, just use django's built in ipv4/ipv6 normalization logic ip_address = request.META.get('REMOTE_ADDR', 'bad address') try: validate_ipv4_address(ip_address) except: try: validate_ipv6_address(ip_address) ip_address = clean_ipv6_address(ip_address, True) except: log.error("Could not parse address {0}".format(ip_address)) ip_address = "127.0.0.1" return ip_address
def get_ip_external_detail(ip_addr, source): """ Get documents matching ip_addr and source """ try: validate_ipv4_address(ip_addr) except ValidationError: return 400, {'status': 'Bad Request', 'code': 400, 'message': 'Not a valid IPV4'} results = [] if ImplementationFactory.instance.is_implemented('ReputationDaoBase'): try: results = ImplementationFactory.instance.get_singleton_of('ReputationDaoBase').get_ip_external_details(ip_addr, source) except ReputationDaoException: pass return 200, results
def get_ip_external_reputation(ip_addr): """ External checks """ try: validate_ipv4_address(ip_addr) except ValidationError: return 400, {'status': 'Bad Request', 'code': 400, 'message': 'Not a valid IPV4'} results = [] if ImplementationFactory.instance.is_implemented('ReputationDaoBase'): try: results = ImplementationFactory.instance.get_singleton_of('ReputationDaoBase').get_ip_external_reputations(ip_addr) except ReputationDaoException: pass return 200, results
def _decorated(view, request, *args, **kwargs): if not settings.ENABLE_LIMIT_IPADDRESS: error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) if request.method in ["DELETE", "POST"]: ipaddress = request.data.get('ipaddress', '') if not ipaddress: error_msg = 'IP address can not be empty.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) try: validate_ipv4_address(ipaddress.replace('*', '1')) except ValidationError: error_msg = "IP address invalid." return api_error(status.HTTP_400_BAD_REQUEST, error_msg) return func(view, request, *args, **kwargs)
def perform_checking(ip): django_validator.validate_ipv4_address(ip) if not netaddr.all_matching_cidrs(ip, ip_ranges) and ip_ranges: raise forms.ValidationError(_("Specified Cluster Static IP is" " not in valid IP range")) try: ip_info = nova.novaclient(request).fixed_ips.get(ip) except exceptions.UNAUTHORIZED: LOG.error("Error to get information about IP address" " using novaclient") exceptions.handle( request, _("Unable to retrieve information " "about fixed IP or IP is not valid."), ignore=True ) except exceptions.NOT_FOUND: msg = "Could not found fixed ips for ip %s" % (ip,) LOG.error(msg) exceptions.handle(request, msg, ignore=True) else: if ip_info.hostname: raise forms.ValidationError(_("Specified Cluster Static IP is already in use"))
def test_filling_IPAddressField(self): try: from test.generic.models import DummyGenericIPAddressFieldModel as IPModel except ImportError: from test.generic.models import DummyIPAddressFieldModel as IPModel obj = mommy.make(IPModel) field = IPModel._meta.get_field('ipv4_field') self.assertIsInstance(field, GenericIPAddressField) self.assertIsInstance(obj.ipv4_field, string_types) validate_ipv4_address(obj.ipv4_field) if hasattr(obj, 'ipv6_field'): self.assertIsInstance(obj.ipv6_field, string_types) self.assertIsInstance(obj.ipv46_field, string_types) validate_ipv6_address(obj.ipv6_field) validate_ipv46_address(obj.ipv46_field)
def _expand_netloc(cls, host, port=None): """ Returns a list of possible domain expansions for ``host`` and ``port``. ``host`` is a hostname like ``'example.com'``. ``port`` is a port number like 8000, or None. Expansions are ordered from highest to lowest preference and may include wildcards. Examples:: >>> AliasManager._expand_netloc('www.example.com') ['www.example.com', '*.example.com', '*.com', '*'] >>> AliasManager._expand_netloc('www.example.com', 80) ['www.example.com:80', 'www.example.com', '*.example.com:80', '*.example.com', '*.com:80', '*.com', '*:80', '*'] """ if not host: raise ValueError(u"Invalid host: %s" % host) try: validate_ipv4_address(host) bits = [host] except ValidationError: # Not an IP address bits = host.split('.') result = [] for i in xrange(0, (len(bits) + 1)): if i == 0: host = '.'.join(bits[i:]) else: host = '.'.join(['*'] + bits[i:]) if port: result.append("%s:%s" % (host, port)) result.append(host) return result