Server IP : 85.214.239.14 / Your IP : 18.191.28.200 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /proc/2/cwd/lib/python3/dist-packages/netaddr/strategy/ |
Upload File : |
#----------------------------------------------------------------------------- # Copyright (c) 2008 by David P. D. Moss. All rights reserved. # # Released under the BSD license. See the LICENSE file for details. #----------------------------------------------------------------------------- """ Shared logic for various address types. """ import re as _re from netaddr.compat import _range, _is_str def bytes_to_bits(): """ :return: A 256 element list containing 8-bit binary digit strings. The list index value is equivalent to its bit string value. """ lookup = [] bits_per_byte = _range(7, -1, -1) for num in range(256): bits = 8 * [None] for i in bits_per_byte: bits[i] = '01'[num & 1] num >>= 1 lookup.append(''.join(bits)) return lookup #: A lookup table of 8-bit integer values to their binary digit bit strings. BYTES_TO_BITS = bytes_to_bits() def valid_words(words, word_size, num_words): """ :param words: A sequence of unsigned integer word values. :param word_size: Width (in bits) of each unsigned integer word value. :param num_words: Number of unsigned integer words expected. :return: ``True`` if word sequence is valid for this address type, ``False`` otherwise. """ if not hasattr(words, '__iter__'): return False if len(words) != num_words: return False max_word = 2 ** word_size - 1 for i in words: if not 0 <= i <= max_word: return False return True def int_to_words(int_val, word_size, num_words): """ :param int_val: Unsigned integer to be divided into words of equal size. :param word_size: Width (in bits) of each unsigned integer word value. :param num_words: Number of unsigned integer words expected. :return: A tuple contain unsigned integer word values split according to provided arguments. """ max_int = 2 ** (num_words * word_size) - 1 if not 0 <= int_val <= max_int: raise IndexError('integer out of bounds: %r!' % hex(int_val)) max_word = 2 ** word_size - 1 words = [] for _ in range(num_words): word = int_val & max_word words.append(int(word)) int_val >>= word_size return tuple(reversed(words)) def words_to_int(words, word_size, num_words): """ :param words: A sequence of unsigned integer word values. :param word_size: Width (in bits) of each unsigned integer word value. :param num_words: Number of unsigned integer words expected. :return: An unsigned integer that is equivalent to value represented by word sequence. """ if not valid_words(words, word_size, num_words): raise ValueError('invalid integer word sequence: %r!' % (words,)) int_val = 0 for i, num in enumerate(reversed(words)): word = num word = word << word_size * i int_val = int_val | word return int_val def valid_bits(bits, width, word_sep=''): """ :param bits: A network address in a delimited binary string format. :param width: Maximum width (in bits) of a network address (excluding delimiters). :param word_sep: (optional) character or string used to delimit word groups (default: '', no separator). :return: ``True`` if network address is valid, ``False`` otherwise. """ if not _is_str(bits): return False if word_sep != '': bits = bits.replace(word_sep, '') if len(bits) != width: return False max_int = 2 ** width - 1 try: if 0 <= int(bits, 2) <= max_int: return True except ValueError: pass return False def bits_to_int(bits, width, word_sep=''): """ :param bits: A network address in a delimited binary string format. :param width: Maximum width (in bits) of a network address (excluding delimiters). :param word_sep: (optional) character or string used to delimit word groups (default: '', no separator). :return: An unsigned integer that is equivalent to value represented by network address in readable binary form. """ if not valid_bits(bits, width, word_sep): raise ValueError('invalid readable binary string: %r!' % (bits,)) if word_sep != '': bits = bits.replace(word_sep, '') return int(bits, 2) def int_to_bits(int_val, word_size, num_words, word_sep=''): """ :param int_val: An unsigned integer. :param word_size: Width (in bits) of each unsigned integer word value. :param num_words: Number of unsigned integer words expected. :param word_sep: (optional) character or string used to delimit word groups (default: '', no separator). :return: A network address in a delimited binary string format that is equivalent in value to unsigned integer. """ bit_words = [] for word in int_to_words(int_val, word_size, num_words): bits = [] while word: bits.append(BYTES_TO_BITS[word & 255]) word >>= 8 bits.reverse() bit_str = ''.join(bits) or '0' * word_size bits = ('0' * word_size + bit_str)[-word_size:] bit_words.append(bits) if word_sep != '': # Check custom separator. if not _is_str(word_sep): raise ValueError('word separator is not a string: %r!' % (word_sep,)) return word_sep.join(bit_words) def valid_bin(bin_val, width): """ :param bin_val: A network address in Python's binary representation format ('0bxxx'). :param width: Maximum width (in bits) of a network address (excluding delimiters). :return: ``True`` if network address is valid, ``False`` otherwise. """ if not _is_str(bin_val): return False if not bin_val.startswith('0b'): return False bin_val = bin_val.replace('0b', '') if len(bin_val) > width: return False max_int = 2 ** width - 1 try: if 0 <= int(bin_val, 2) <= max_int: return True except ValueError: pass return False def int_to_bin(int_val, width): """ :param int_val: An unsigned integer. :param width: Maximum allowed width (in bits) of a unsigned integer. :return: Equivalent string value in Python's binary representation format ('0bxxx'). """ bin_tokens = [] try: # Python 2.6.x and upwards. bin_val = bin(int_val) except NameError: # Python 2.4.x and 2.5.x i = int_val while i > 0: word = i & 0xff bin_tokens.append(BYTES_TO_BITS[word]) i >>= 8 bin_tokens.reverse() bin_val = '0b' + _re.sub(r'^[0]+([01]+)$', r'\1', ''.join(bin_tokens)) if len(bin_val[2:]) > width: raise IndexError('binary string out of bounds: %s!' % (bin_val,)) return bin_val def bin_to_int(bin_val, width): """ :param bin_val: A string containing an unsigned integer in Python's binary representation format ('0bxxx'). :param width: Maximum allowed width (in bits) of a unsigned integer. :return: An unsigned integer that is equivalent to value represented by Python binary string format. """ if not valid_bin(bin_val, width): raise ValueError('not a valid Python binary string: %r!' % (bin_val,)) return int(bin_val.replace('0b', ''), 2)