def setQuestion(self, qname, qtype=QTYPE_A, qclass=QCLASS_IN):
for label in qname.split('.'):
label = str(label)
l = len(label)
self.buf += struct_pack('b', l)
self.buf += struct_pack(str(l)+'s', label)
self.buf += '\0'
self.buf += self._pack16bit(qtype)
self.buf += self._pack16bit(qclass)
def tick(self,sample,sample2=None): if (sample2 == None): s1 = int(self.sampleScale*sample) s1 = clip_value(s1,-self.sampleScale,self.sampleScale) self.wavFile.writeframes(struct_pack(self.packFormat,s1)) return sample else: s1 = int(self.sampleScale*sample) s1 = clip_value(s1,-self.sampleScale,self.sampleScale) s2 = int(self.sampleScale*sample2) s2 = clip_value(s2,-self.sampleScale,self.sampleScale) self.wavFile.writeframes(struct_pack(self.packFormat,s1)) self.wavFile.writeframes(struct_pack(self.packFormat,s2)) return (sample,sample2)
def encode_time(value):
if value.microsecond > 0:
val = (
value.microsecond |
value.second << 20 |
value.minute << 26 |
value.hour << 32
)
return DYN_COL_TIME, struct_pack('Q', val)[:6]
else:
val = (
value.second |
value.minute << 6 |
value.hour << 12
)
return DYN_COL_TIME, struct_pack('I', val)[:3]
def bool_to_bitarray(value):
"""
Converts a numpy boolean array to a bit array (a string of bits in
a bytes object).
Parameters
----------
value : numpy bool array
Returns
-------
bit_array : bytes
The first value in the input array will be the most
significant bit in the result. The length will be `floor((N +
7) / 8)` where `N` is the length of `value`.
"""
value = value.flat
bit_no = 7
byte = 0
bytes = []
for v in value:
if v:
byte |= 1 << bit_no
if bit_no == 0:
bytes.append(byte)
bit_no = 7
byte = 0
else:
bit_no -= 1
if bit_no != 7:
bytes.append(byte)
return struct_pack("%sB" % len(bytes), *bytes)
def pack_test(self, string, buffsize):
""" packs wireless request data for sending it to the kernel """
buffsize = buffsize - len(string)
buff = array('c', string+'\0'*buffsize)
caddr_t, length = buff.buffer_info()
s = struct_pack('Pii', caddr_t, length, 1)
return buff, s
def encode_float(value):
if isnan(value) or isinf(value):
raise DynColValueError("Float value not encodeable: {}".format(value))
encvalue = struct_pack('d', value)
# -0.0 is not supported in SQL, change to 0.0
if encvalue == b'\x00\x00\x00\x00\x00\x00\x00\x80':
encvalue = b'\x00\x00\x00\x00\x00\x00\x00\x00'
return DYN_COL_DOUBLE, encvalue
def pack_wrq(self, buffsize):
""" packs wireless request data for sending it to the kernel """
# Prepare a buffer
# We need the address of our buffer and the size for it. The
# ioctl itself looks for the pointer to the address in our
# memory and the size of it.
# Dont change the order how the structure is packed!!!
buff = array('c', '\0'*buffsize)
caddr_t, length = buff.buffer_info()
s = struct_pack('Pi', caddr_t, length)
return buff, s
def snappy_emit_backref(f, offset, length):
if 4 <= length <= 11 and offset < 2048:
f.write(chr(1 | ((length - 4) << 2) | ((offset >> 8) << 5)))
f.write(chr(offset & 255))
else: # a back offset with offset > 65536 is not supported by this encoder!
encoded_offset = struct_pack("<H", offset)
while length > 0:
curr_len_chunk = min(length, 64)
f.write(chr(2 | ((curr_len_chunk - 1) << 2)))
f.write(encoded_offset)
length -= curr_len_chunk
def pack_bytes_header(self, size):
stream = self.stream
if size < PLUS_2_TO_THE_8:
stream.write(BYTES_8)
stream.write(PACKED_UINT_8[size])
elif size < PLUS_2_TO_THE_16:
stream.write(BYTES_16)
stream.write(PACKED_UINT_16[size])
elif size < PLUS_2_TO_THE_32:
stream.write(BYTES_32)
stream.write(struct_pack(UINT_32_STRUCT, size))
else:
raise OverflowError("Bytes header size out of range")
def a_qr_str(self, grupo_cat=None, con_dnis=True):
"""Devuelve la informacion del recuento para almacenar en qr."""
encoded_data = self.a_tag(grupo_cat, con_dnis)
datos = bytearray(b"")
# Agregamos el Token
datos.append(int(TOKEN, 16))
# agregamos el largo de los datos en 2 bytes
len_data = len(encoded_data) * 2
datos.extend(struct_pack(">H", len_data))
# metemos el resto de los datos
datos.extend(encoded_data)
# lo encodeamos en hexa y lo pasamos a mayúsculas
todo = encode(datos, "hex_codec").decode().upper()
return todo
def pack_string_header(self, size):
stream = self.stream
if size < PLUS_2_TO_THE_4:
stream.write(TINY_STRING[size])
elif size < PLUS_2_TO_THE_8:
stream.write(STRING_8)
stream.write(PACKED_UINT_8[size])
elif size < PLUS_2_TO_THE_16:
stream.write(STRING_16)
stream.write(PACKED_UINT_16[size])
elif size < PLUS_2_TO_THE_32:
stream.write(STRING_32)
stream.write(struct_pack(UINT_32_STRUCT, size))
else:
raise OverflowError("String header size out of range")
def pack_map_header(self, size):
stream = self.stream
if size < PLUS_2_TO_THE_4:
stream.write(TINY_MAP[size])
elif size < PLUS_2_TO_THE_8:
stream.write(MAP_8)
stream.write(PACKED_UINT_8[size])
elif size < PLUS_2_TO_THE_16:
stream.write(MAP_16)
stream.write(PACKED_UINT_16[size])
elif size < PLUS_2_TO_THE_32:
stream.write(MAP_32)
stream.write(struct_pack(UINT_32_STRUCT, size))
else:
raise OverflowError("Map header size out of range")
def flush(self, end_of_message=False):
""" Flush everything written since the last chunk to the
stream, followed by a zero-chunk if required.
"""
output_buffer = self.output_buffer
if output_buffer:
lines = [struct_pack(">H", self.output_size)] + output_buffer
else:
lines = []
if end_of_message:
lines.append(b"\x00\x00")
if lines:
self.raw.writelines(lines)
self.raw.flush()
del output_buffer[:]
self.output_size = 0
def encode_int(value):
if value < 0:
dtype = DYN_COL_INT
encvalue = -(value << 1) - 1
if value < -(2 ** 32 - 1):
raise DynColValueError("int {} out of range".format(value))
else:
if value <= (2 ** 63 - 1):
dtype = DYN_COL_INT
encvalue = value << 1
elif value <= (2 ** 64 - 1):
dtype = DYN_COL_UINT
encvalue = value
else:
raise DynColValueError("int {} out of range".format(value))
to_enc = []
while encvalue:
to_enc.append(encvalue & 0xff)
encvalue = encvalue >> 8
return dtype, struct_pack('B' * len(to_enc), *to_enc)
def binoutput(self, value, mask):
if np.any(mask):
vo_warn(W39)
value = value.flat
bit_no = 7
byte = 0
bytes = []
for v in value:
if v:
byte |= 1 << bit_no
if bit_no == 0:
bytes.append(byte)
bit_no = 7
byte = 0
else:
bit_no -= 1
if bit_no != 7:
bytes.append(byte)
assert len(bytes) == self._bytes
return struct_pack("%sB" % len(bytes), *bytes)
def rgb2hex(rgb):
return '#' + binascii.hexlify(struct_pack('BBB', *rgb)).decode('ascii')
def int_to_ip_address(address):
return inet_ntoa(struct_pack("!I", address))
def _swap32b(i):
"""swap endianness of an uint32"""
return struct_unpack('<I', struct_pack('>I', i))[0]
def _padded(s):
"""return str `s` padded with zeroes to align to the 32-bit boundary"""
return struct_pack('%ss' % _align32b(len(s)), s)
def pack32bit(n):
return struct_pack('!L', n)
def _pack16bit(self,n):
return struct_pack('!H', n)
def int_to_ip_address(address):
return socket.inet_ntoa(struct_pack("!I", address))
def __bytes__(self) -> bytes:
return b''.join([
bytes(self.service_config),
struct_pack('<I', self.bytes_needed),
struct_pack('<I', self.return_code.value)
])
def connect(host_port, ssl_context=None, **config):
""" Connect and perform a handshake and return a valid Connection object, assuming
a protocol version can be agreed.
"""
# Establish a connection to the host and port specified
# Catches refused connections see:
# https://docs.python.org/2/library/errno.html
if __debug__: log_info("~~ [CONNECT] %s", host_port)
try:
s = create_connection(host_port)
except SocketError as error:
if error.errno == 111 or error.errno == 61:
raise ProtocolError("Unable to connect to %s on port %d - is the server running?" % host_port)
else:
raise
# Secure the connection if an SSL context has been provided
if ssl_context and SSL_AVAILABLE:
host, port = host_port
if __debug__: log_info("~~ [SECURE] %s", host)
try:
s = ssl_context.wrap_socket(s, server_hostname=host if HAS_SNI else None)
except SSLError as cause:
error = ProtocolError("Cannot establish secure connection; %s" % cause.args[1])
error.__cause__ = cause
raise error
else:
# Check that the server provides a certificate
der_encoded_server_certificate = s.getpeercert(binary_form=True)
if der_encoded_server_certificate is None:
raise ProtocolError("When using a secure socket, the server should always provide a certificate")
trust = config.get("trust", TRUST_DEFAULT)
if trust == TRUST_ON_FIRST_USE:
store = PersonalCertificateStore()
if not store.match_or_trust(host, der_encoded_server_certificate):
raise ProtocolError("Server certificate does not match known certificate for %r; check "
"details in file %r" % (host, KNOWN_HOSTS))
else:
der_encoded_server_certificate = None
# Send details of the protocol versions supported
supported_versions = [1, 0, 0, 0]
handshake = [MAGIC_PREAMBLE] + supported_versions
if __debug__: log_info("C: [HANDSHAKE] 0x%X %r", MAGIC_PREAMBLE, supported_versions)
data = b"".join(struct_pack(">I", num) for num in handshake)
if __debug__: log_debug("C: %s", ":".join(map(hex2, data)))
s.sendall(data)
# Handle the handshake response
ready_to_read, _, _ = select((s,), (), (), 0)
while not ready_to_read:
ready_to_read, _, _ = select((s,), (), (), 0)
data = s.recv(4)
data_size = len(data)
if data_size == 0:
# If no data is returned after a successful select
# response, the server has closed the connection
log_error("S: [CLOSE]")
raise ProtocolError("Server closed connection without responding to handshake")
if data_size == 4:
if __debug__: log_debug("S: %s", ":".join(map(hex2, data)))
else:
# Some other garbled data has been received
log_error("S: @*#!")
raise ProtocolError("Expected four byte handshake response, received %r instead" % data)
agreed_version, = struct_unpack(">I", data)
if __debug__: log_info("S: [HANDSHAKE] %d", agreed_version)
if agreed_version == 0:
if __debug__: log_info("~~ [CLOSE]")
s.shutdown(SHUT_RDWR)
s.close()
elif agreed_version == 1:
return Connection(s, der_encoded_server_certificate=der_encoded_server_certificate, **config)
elif agreed_version == 1213486160:
log_error("S: [CLOSE]")
raise ProtocolError("Server responded HTTP. Make sure you are not trying to connect to the http endpoint " +
"(HTTP defaults to port 7474 whereas BOLT defaults to port 7687)")
else:
log_error("S: [CLOSE]")
raise ProtocolError("Unknown Bolt protocol version: %d", agreed_version)
def _write_length(length):
return struct_pack(">I", int(length))
def bin2addr(n):
return inet_ntoa(struct_pack('!L', n))
def _binoutput_fixed(self, value, mask):
if mask:
value = u''
return struct_pack(self._struct_format, value.encode('utf_16_be'))
def __bytes__(self) -> bytes:
return self.service_handle + struct_pack('<I', self.buf_size)
def _binoutput_fixed(self, value, mask):
if mask:
value = _empty_bytes
return struct_pack(self._struct_format, value)
def _binoutput_fixed(self, value, mask):
if mask:
value = _empty_bytes
return struct_pack(self._struct_format, value)
def pack(self, fmt, *args):
""" calls struct_pack and returns the result """
return struct_pack(fmt, *args)
def encode_date(value):
# We don't need any validation since datetime.date is more limited than the
# MySQL format
val = value.day | value.month << 5 | value.year << 9
return DYN_COL_DATE, struct_pack('I', val)[:-1]
def _write_length(length):
return struct_pack(">I", int(length))
def pack32bit(n):
return struct_pack('!L', n)
def _binoutput_fixed(self, value, mask):
if mask:
value = u''
return struct_pack(self._struct_format, value.encode('utf_16_be'))
def make_length_prefix(count: int) -> bytes:
return struct_pack('<H', count)
def pack16bit(n):
return struct_pack('!H', n)
def pack(dicty):
"""
Convert a mapping into the MariaDB dynamic columns format
"""
column_count = 0
column_directory = []
directory_offset = 0
name_offset = 0
names = []
data_offset = 0
data = []
total_encname_length = 0
dicty_names_encoded = {
key.encode('utf-8'): value
for key, value in six_iteritems(dicty)
}
for encname in sorted(six_iterkeys(dicty_names_encoded), key=name_order):
value = dicty_names_encoded[encname]
if value is None:
continue
if len(encname) > MAX_NAME_LENGTH:
raise DynColLimitError("Key too long: " + encname.decode('utf-8'))
total_encname_length += len(encname)
if total_encname_length > MAX_TOTAL_NAME_LENGTH:
raise DynColLimitError("Total length of keys too long")
try:
encode_func = ENCODE_FUNCS[type(value)]
except KeyError:
raise DynColTypeError("Unencodable type {}".format(type(value)))
dtype, encvalue = encode_func(value)
column_count += 1
column_directory.append(name_offset)
column_directory.append((data_offset << 4) + dtype)
names.append(encname)
name_offset += len(encname)
data.append(encvalue)
data_offset += len(encvalue)
directory_offset += 2
data_size_flag, coldir_size_code, odd_sized_datacode = data_size(data)
flags = (
4 | # means this contains named dynamic columns
data_size_flag
)
enc_names = b''.join(names)
buf = [
struct_pack(
'<BHH',
flags,
column_count,
len(enc_names)
),
]
if not odd_sized_datacode:
buf.append(
struct_pack(
'<' + ('H' + coldir_size_code) * (len(column_directory) // 2),
*column_directory
)
)
else:
for i, val in enumerate(column_directory):
if i % 2 == 0:
# name_offset
buf.append(struct_pack('<H', val))
else:
# data_offset + dtype, have to cut last byte
val = struct_pack('<' + coldir_size_code, val)
buf.append(val[:-1])
buf.append(enc_names)
buf.extend(data)
return b''.join(buf)
def bin2addr(n):
return inet_ntoa(struct_pack('!L', n))
def pack16bit(n):
return struct_pack('!H', n)