def setup(self):
eof = self._kwargs.get('eof', False)
self.ok_header = Datum('int<1>', 0xFE if eof is True else 0)
self.affected_rows = Datum('int<lenenc>', self._kwargs.get('affected_rows', 0))
self.last_insert_id = Datum('int<lenenc>', 0)
status = self._kwargs.get('status', 0x0002)
self.server_status = Datum('int<2>', status)
# Datum('int<2>', 0)
self.warning_count = Datum('int<2>', 0)
self.state_track = None
state_track = self._kwargs.get('state_track') # [[key: value]]
if state_track is not None:
accum = b''
status = status | SERVER_STATUS.SERVER_SESSION_STATE_CHANGED
self.server_status = Datum('int<2>', status)
self.state_track = b''
self.state_track += Datum('string<lenenc>', '').toStringPacket() # 'info' - human readable status information
for el in state_track:
# NOTE at this moment just system variables
name, value = el
part = Datum('string<lenenc>', name).toStringPacket()
part += Datum('string<lenenc>', value).toStringPacket()
accum += struct.pack('i', SESSION_TRACK.SESSION_TRACK_SYSTEM_VARIABLES)[:1] + struct.pack('i', len(part))[:1] + part
# self.state_track
# self.state_track.append(Datum('string<lenenc>', '')
accum = struct.pack('i', len(accum))[:1] + accum
self.state_track += accum
self.info = Datum('string<EOF>')
def setup(self):
status = 0 if 'status' not in self._kwargs else self._kwargs['status']
seed = self._kwargs['seed']
method = self._kwargs['method']
self.eof_header = Datum('int<1>', int('0xfe', 0))
self.authentication_plugin_name = Datum('string<NUL>', method)
self.seed = Datum('string<NUL>', seed)
class CommandPacket(Packet):
'''
Implementation based on description:
https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
'''
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value == COMMANDS.COM_QUERY:
self.sql = Datum('str<EOF>')
self.sql.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
self.data.setFromBuff(buffer)
def __str__(self):
return str({
'header': {
'length': self.length,
'seq': self.seq
},
'type': getConstName(COMMANDS, self.type.value),
'vars': self.__dict__
})
def setup(self, length=0, count_header=1, body=''):
length = len(body)
if length == 0:
return
self.password = Datum('string<NUL>')
buffer = body
buffer = self.password.setFromBuff(buffer)
def setup(self, length=0, count_header=1, body=''):
length = len(body)
if length == 0:
self.password = b''
return
self.enc_password = Datum('string<EOF>') # 0x04
buffer = body
buffer = self.enc_password.setFromBuff(buffer)
self.password = self.enc_password.value
def setup(self):
err_code = 0
if 'err_code' in self._kwargs:
err_code = self._kwargs['err_code']
msg = 'ERROR'
if 'msg' in self._kwargs:
msg = self._kwargs['msg']
self.err_header = Datum('int<1>', 255)
self.err_code = Datum('int<2>', err_code)
self.msg = Datum('string<EOF>', msg)
def read_params(self, buffer, num_params):
if not num_params > 0:
return
# read null-map
null_bytes = math.floor((num_params + 7) / 8)
nulls = []
for i in range(null_bytes):
b, buffer = self._read_byte(buffer)
for i in range(8):
nulls.append(((1 << i) & b) != 0)
# read send-type byte
b, buffer = self._read_byte(buffer)
types = []
if b == 1:
# read types
for i in range(num_params):
t, buffer = self._read_byte(buffer)
s, buffer = self._read_byte(buffer)
types.append(dict(type=t, signed=s))
datumtypes = {
TYPES.MYSQL_TYPE_VAR_STRING: 'string<lenenc>',
TYPES.MYSQL_TYPE_STRING: 'string<lenenc>',
TYPES.MYSQL_TYPE_VARCHAR: 'string<lenenc>',
TYPES.MYSQL_TYPE_TINY: 'int<1>',
TYPES.MYSQL_TYPE_SHORT: 'int<2>',
TYPES.MYSQL_TYPE_LONG: 'int<4>',
TYPES.MYSQL_TYPE_LONGLONG: 'int<8>',
}
for i in range(num_params):
if nulls[i]:
self.parameters.append(None)
continue
datum_type = datumtypes.get(types[i]['type'])
if datum_type is not None:
x = Datum(datum_type)
buffer = x.setFromBuff(buffer)
value = x.value
if isinstance(value, bytes):
value = value.decode()
self.parameters.append(value)
else:
# NOTE at this moment all sends as strings and it works
raise Exception(f"Unsupported type {types[i]['type']}")
def setup(self):
data = self._kwargs.get('data', {})
self.value = []
for val in data:
if val is None:
self.value.append(NULL_VALUE)
else:
self.value.append(Datum('string<lenenc>', str(val)))
class SwitchOutResponse(Packet):
def setup(self, length=0, count_header=1, body=''):
length = len(body)
if length == 0:
return
self.enc_password = Datum('string<EOF>') # 0x04
buffer = body
buffer = self.enc_password.setFromBuff(buffer)
def setup(self):
data = self._kwargs.get('data', {})
columns = self._kwargs.get('columns', {})
self.value = [b'\x00']
nulls = [0]
for i, el in enumerate(data):
if i > 0 and (i + 2) % 8 == 0:
nulls.append(0)
if el is None:
if i < 6:
nulls[-1] = nulls[-1] + (1 << ((i + 2) % 8))
else:
nulls[-1] = nulls[-1] + (1 << ((i - 6) % 8))
self.value.append(bytes(nulls))
for i, col in enumerate(columns):
# NOTE at this moment all types sends as strings, and it works
if data[i] is None:
continue
enc = ''
col_type = col['type']
if col_type == TYPES.MYSQL_TYPE_DOUBLE:
enc = '<d'
elif col_type == TYPES.MYSQL_TYPE_LONGLONG:
enc = '<q'
elif col_type == TYPES.MYSQL_TYPE_LONG:
enc = '<l'
elif col_type == TYPES.MYSQL_TYPE_FLOAT:
enc = '<f'
elif col_type == TYPES.MYSQL_TYPE_YEAR:
enc = '<h'
elif col_type == TYPES.MYSQL_TYPE_DATE:
enc = ''
elif col_type == TYPES.MYSQL_TYPE_TIMESTAMP:
enc = ''
elif col_type == TYPES.MYSQL_TYPE_DATETIME:
enc = ''
elif col_type == TYPES.MYSQL_TYPE_TIME:
enc = ''
elif col_type == TYPES.MYSQL_TYPE_NEWDECIMAL:
enc = ''
else:
enc = 'string'
if enc == '':
raise Exception(
f'Column with type {col_type} cant be encripted')
if enc == 'string':
self.value.append(
Datum('string<lenenc>', str(data[i])).toStringPacket())
else:
self.value.append(struct.encode(enc, data[i]))[0]
def setup(self):
self.status = Datum('int<1>', 0)
self.stmt_id = Datum('int<4>', self._kwargs.get('stmt_id', 1))
self.num_columns = Datum('int<2>', self._kwargs.get('num_columns', 0))
self.num_params = Datum('int<2>', self._kwargs.get('num_params', 0))
self.filler = Datum('int<1>', 0)
self.warning_count = Datum('int<2>', 0)
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value == COMMANDS.COM_QUERY:
self.sql = Datum('str<EOF>')
self.sql.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
self.data.setFromBuff(buffer)
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value in (COMMANDS.COM_QUERY, COMMANDS.COM_STMT_PREPARE):
self.sql = Datum('str<EOF>')
buffer = self.sql.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_EXECUTE:
# https://mariadb.com/kb/en/com_stmt_execute/
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.flags = Datum('int<1>')
buffer = self.flags.setFromBuff(buffer)
self.iteration_count = Datum('int<4>')
buffer = self.iteration_count.setFromBuff(buffer)
self.parameters = []
prepared_stmt = self.session.prepared_stmts[self.stmt_id.value]
if prepared_stmt['type'] == 'select':
num_params = len(prepared_stmt['statement'].parameters)
self.read_params(buffer, num_params)
elif prepared_stmt['type'] in ['insert', 'delete']:
# if prepared_stmt['type'] == 'insert':
# prepared_stmt['statement'].sql
# statement = parse_sql(prepared_stmt['statement'].sql)
# num_params = 0
# for row in statement.values:
# for item in row:
# if isinstance(item, Parameter):
# num_params = num_params + 1
# elif prepared_stmt['type'] == 'delete':
# num_params = prepared_stmt['statement'].sql.count('?')
num_params = len(prepared_stmt['statement'].parameters)
self.read_params(buffer, num_params)
elif self.type.value == COMMANDS.COM_STMT_CLOSE:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_FETCH:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.limit = Datum('int<4>')
buffer = self.limit.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_INIT_DB:
self.database = Datum('str<EOF>')
buffer = self.database.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
buffer = self.data.setFromBuff(buffer)
class CommandPacket(Packet):
'''
Implementation based on description:
https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
'''
def _read_byte(self, buffer):
b = buffer[:1]
buffer = buffer[1:]
b = struct.unpack('<B', b)[0]
return b, buffer
def read_params(self, buffer, num_params):
if not num_params > 0:
return
# read null-map
null_bytes = math.floor((num_params + 7) / 8)
nulls = []
for i in range(null_bytes):
b, buffer = self._read_byte(buffer)
for i in range(8):
nulls.append(((1 << i) & b) != 0)
# read send-type byte
b, buffer = self._read_byte(buffer)
types = []
if b == 1:
# read types
for i in range(num_params):
t, buffer = self._read_byte(buffer)
s, buffer = self._read_byte(buffer)
types.append(dict(type=t, signed=s))
datumtypes = {
TYPES.MYSQL_TYPE_VAR_STRING: 'string<lenenc>',
TYPES.MYSQL_TYPE_STRING: 'string<lenenc>',
TYPES.MYSQL_TYPE_VARCHAR: 'string<lenenc>',
TYPES.MYSQL_TYPE_TINY: 'int<1>',
TYPES.MYSQL_TYPE_SHORT: 'int<2>',
TYPES.MYSQL_TYPE_LONG: 'int<4>',
TYPES.MYSQL_TYPE_LONGLONG: 'int<8>',
}
for i in range(num_params):
if nulls[i]:
self.parameters.append(None)
continue
datum_type = datumtypes.get(types[i]['type'])
if datum_type is not None:
x = Datum(datum_type)
buffer = x.setFromBuff(buffer)
value = x.value
if isinstance(value, bytes):
value = value.decode()
self.parameters.append(value)
else:
# NOTE at this moment all sends as strings and it works
raise Exception(f"Unsupported type {types[i]['type']}")
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value in (COMMANDS.COM_QUERY, COMMANDS.COM_STMT_PREPARE):
self.sql = Datum('str<EOF>')
buffer = self.sql.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_EXECUTE:
# https://mariadb.com/kb/en/com_stmt_execute/
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.flags = Datum('int<1>')
buffer = self.flags.setFromBuff(buffer)
self.iteration_count = Datum('int<4>')
buffer = self.iteration_count.setFromBuff(buffer)
self.parameters = []
prepared_stmt = self.session.prepared_stmts[self.stmt_id.value]
if prepared_stmt['type'] == 'select':
num_params = len(prepared_stmt['statement'].parameters)
self.read_params(buffer, num_params)
elif prepared_stmt['type'] in ['insert', 'delete']:
# if prepared_stmt['type'] == 'insert':
# prepared_stmt['statement'].sql
# statement = parse_sql(prepared_stmt['statement'].sql)
# num_params = 0
# for row in statement.values:
# for item in row:
# if isinstance(item, Parameter):
# num_params = num_params + 1
# elif prepared_stmt['type'] == 'delete':
# num_params = prepared_stmt['statement'].sql.count('?')
num_params = len(prepared_stmt['statement'].parameters)
self.read_params(buffer, num_params)
elif self.type.value == COMMANDS.COM_STMT_CLOSE:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_FETCH:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.limit = Datum('int<4>')
buffer = self.limit.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_INIT_DB:
self.database = Datum('str<EOF>')
buffer = self.database.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
buffer = self.data.setFromBuff(buffer)
def __str__(self):
return str({
'header': {
'length': self.length,
'seq': self.seq
},
'type': getConstName(COMMANDS, self.type.value),
'vars': self.__dict__
})
def setup(self, length=0, count_header=1, body=''):
length = len(body)
if length == 0:
return
self.salt = self.proxy.salt
self._length = length
self._seq = count_header
self._body = body
self.scramble_func = scramble
self.capabilities = Datum('int<4>')
self.max_packet_size = Datum('int<4>')
self.reserved = Datum('string<23>')
self.username = Datum('string<NUL>')
self.enc_password = Datum('string<NUL>')
self.database = Datum('string<NUL>')
self.charset = Datum('int<1>')
self.client_auth_plugin = Datum('string<NUL>')
buffer = body
if len(body) == 32 and body[9:] == (b'\x00' * 23):
self.type = 'SSLRequest'
buffer = self.capabilities.setFromBuff(buffer)
buffer = self.max_packet_size.setFromBuff(buffer)
buffer = self.charset.setFromBuff(buffer)
else:
self.type = 'HandshakeResponse'
buffer = self.capabilities.setFromBuff(buffer)
capabilities = ClentCapabilities(self.capabilities.value)
buffer = self.max_packet_size.setFromBuff(buffer)
buffer = self.charset.setFromBuff(buffer)
buffer = self.reserved.setFromBuff(buffer)
buffer = self.username.setFromBuff(buffer)
if server_capabilities.has(CAPABILITIES.CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA) \
and capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA:
self.enc_password = Datum('string<lenenc>')
buffer = self.enc_password.setFromBuff(buffer)
elif server_capabilities.has(CAPABILITIES.CLIENT_SECURE_CONNECTION) \
and capabilities.SECURE_CONNECTION:
self.auth_resp_len = Datum('int<1>')
buffer = self.auth_resp_len.setFromBuff(buffer)
self.enc_password = Datum(
f'string<{self.auth_resp_len.value}>')
buffer = self.enc_password.setFromBuff(buffer)
else:
pass_byte = Datum('int<1>')
buffer = pass_byte.setFromBuff(buffer)
if capabilities.CONNECT_WITH_DB:
buffer = self.database.setFromBuff(buffer)
if capabilities.PLUGIN_AUTH:
buffer = self.client_auth_plugin.setFromBuff(buffer)
# at the end is CLIENT_CONNECT_ATTRS, but we dont use it and dont parse
self.session.username = self.username.value
class CommandPacket(Packet):
'''
Implementation based on description:
https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
'''
def _read_byte(self, buffer):
b = buffer[:1]
buffer = buffer[1:]
b = struct.unpack('<B', b)[0]
return b, buffer
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value in (COMMANDS.COM_QUERY, COMMANDS.COM_STMT_PREPARE):
self.sql = Datum('str<EOF>')
buffer = self.sql.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_EXECUTE:
# https://mariadb.com/kb/en/com_stmt_execute/
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.flags = Datum('int<1>')
buffer = self.flags.setFromBuff(buffer)
self.iteration_count = Datum('int<4>')
buffer = self.iteration_count.setFromBuff(buffer)
self.parameters = []
statement = self.session.statements[self.stmt_id.value]
if statement['type'] in ['insert', 'delete']:
num_params = len(statement['insert']
) if statement['type'] == 'insert' else 1
if num_params > 0:
# read null-map
null_bytes = math.floor((num_params + 7) / 8)
nulls = []
for i in range(null_bytes):
b, buffer = self._read_byte(buffer)
for i in range(8):
nulls.append(((1 << i) & b) != 0)
# read send-type byte
b, buffer = self._read_byte(buffer)
types = []
if b == 1:
# read types
for i in range(num_params):
t, buffer = self._read_byte(buffer)
s, buffer = self._read_byte(buffer)
types.append(dict(type=t, signed=s))
self.parameters = []
for i in range(num_params):
if nulls[i]:
self.parameters.append(None)
continue
if types[i]['type'] in (TYPES.MYSQL_TYPE_VAR_STRING,
TYPES.MYSQL_TYPE_STRING):
x = Datum('string<lenenc>')
buffer = x.setFromBuff(buffer)
self.parameters.append(x.value.decode())
else:
# NOTE at this moment all sends as strings and it works
raise Exception(
f"Unsupported type {types[i]['type']}")
elif self.type.value == COMMANDS.COM_STMT_CLOSE:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_FETCH:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.limit = Datum('int<4>')
buffer = self.limit.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
buffer = self.data.setFromBuff(buffer)
def __str__(self):
return str({
'header': {
'length': self.length,
'seq': self.seq
},
'type': getConstName(COMMANDS, self.type.value),
'vars': self.__dict__
})
def setup(self):
count = self._kwargs.get('count', 0)
self.column_count = Datum('int<lenenc>', count)
class HandshakeResponsePacket(Packet):
'''
Implementation based on description:
https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
'''
def setup(self, length=0, count_header=1, body=''):
length = len(body)
if length == 0:
return
self.salt = self.proxy.salt
self._length = length
self._seq = count_header
self._body = body
self.scramble_func = scramble
self.capabilities = Datum('int<4>')
self.max_packet_size = Datum('int<4>')
self.reserved = Datum('string<23>')
self.username = Datum('string<NUL>')
self.enc_password = Datum('string<NUL>')
self.database = Datum('string<NUL>')
self.charset = Datum('int<1>')
self.client_auth_plugin = Datum('string<NUL>')
buffer = body
if len(body) == 32 and body[9:] == (b'\x00' * 23):
self.type = 'SSLRequest'
buffer = self.capabilities.setFromBuff(buffer)
buffer = self.max_packet_size.setFromBuff(buffer)
buffer = self.charset.setFromBuff(buffer)
else:
self.type = 'HandshakeResponse'
buffer = self.capabilities.setFromBuff(buffer)
capabilities = ClentCapabilities(self.capabilities.value)
buffer = self.max_packet_size.setFromBuff(buffer)
buffer = self.charset.setFromBuff(buffer)
buffer = self.reserved.setFromBuff(buffer)
buffer = self.username.setFromBuff(buffer)
if server_capabilities.has(CAPABILITIES.CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA) \
and capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA:
self.enc_password = Datum('string<lenenc>')
buffer = self.enc_password.setFromBuff(buffer)
elif server_capabilities.has(CAPABILITIES.CLIENT_SECURE_CONNECTION) \
and capabilities.SECURE_CONNECTION:
self.auth_resp_len = Datum('int<1>')
buffer = self.auth_resp_len.setFromBuff(buffer)
self.enc_password = Datum(
f'string<{self.auth_resp_len.value}>')
buffer = self.enc_password.setFromBuff(buffer)
else:
pass_byte = Datum('int<1>')
buffer = pass_byte.setFromBuff(buffer)
if capabilities.CONNECT_WITH_DB:
buffer = self.database.setFromBuff(buffer)
if capabilities.PLUGIN_AUTH:
buffer = self.client_auth_plugin.setFromBuff(buffer)
# at the end is CLIENT_CONNECT_ATTRS, but we dont use it and dont parse
self.session.username = self.username.value
def __str__(self):
return str({
'header': {
'length': self.length,
'seq': self.seq
},
'username': self.username.value,
'password': self.enc_password.value,
'database': self.database.value
})
def setup(self, length=0, count_header=1, body=''):
if length == 0:
return
# self.salt=self.session.salt
self._length = length
self._seq = count_header
self._body = body
self.type = Datum('int<1>')
buffer = body
buffer = self.type.setFromBuff(buffer)
if self.type.value in (COMMANDS.COM_QUERY, COMMANDS.COM_STMT_PREPARE):
self.sql = Datum('str<EOF>')
buffer = self.sql.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_EXECUTE:
# https://mariadb.com/kb/en/com_stmt_execute/
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.flags = Datum('int<1>')
buffer = self.flags.setFromBuff(buffer)
self.iteration_count = Datum('int<4>')
buffer = self.iteration_count.setFromBuff(buffer)
self.parameters = []
prepared_stmt = self.session.prepared_stmts[self.stmt_id.value]
if prepared_stmt['type'] in ['insert', 'delete']:
if prepared_stmt['type'] == 'insert':
num_params = prepared_stmt['statement'].struct[
'values'].count(SQL_PARAMETER)
elif prepared_stmt['type'] == 'delete':
num_params = prepared_stmt['statement'].sql.count('?')
if num_params > 0:
# read null-map
null_bytes = math.floor((num_params + 7) / 8)
nulls = []
for i in range(null_bytes):
b, buffer = self._read_byte(buffer)
for i in range(8):
nulls.append(((1 << i) & b) != 0)
# read send-type byte
b, buffer = self._read_byte(buffer)
types = []
if b == 1:
# read types
for i in range(num_params):
t, buffer = self._read_byte(buffer)
s, buffer = self._read_byte(buffer)
types.append(dict(type=t, signed=s))
self.parameters = []
for i in range(num_params):
if nulls[i]:
self.parameters.append(None)
continue
if types[i]['type'] in (TYPES.MYSQL_TYPE_VAR_STRING,
TYPES.MYSQL_TYPE_STRING):
x = Datum('string<lenenc>')
buffer = x.setFromBuff(buffer)
self.parameters.append(x.value.decode())
else:
# NOTE at this moment all sends as strings and it works
raise Exception(
f"Unsupported type {types[i]['type']}")
elif self.type.value == COMMANDS.COM_STMT_CLOSE:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
elif self.type.value == COMMANDS.COM_STMT_FETCH:
self.stmt_id = Datum('int<4>')
buffer = self.stmt_id.setFromBuff(buffer)
self.limit = Datum('int<4>')
buffer = self.limit.setFromBuff(buffer)
else:
self.data = Datum('str<EOF>')
buffer = self.data.setFromBuff(buffer)
def setup(self):
status = 0 if 'status' not in self._kwargs else self._kwargs['status']
self.eof_header = Datum('int<1>', int('0xfe', 0))
self.warning_count = Datum('int<2>', 0)
self.server_status = Datum('int<2>', status)
def setup(self):
capabilities = server_capabilities.value
self.protocol_version = Datum('int<1>', 10)
self.server_version = Datum('string<NUL>', '5.7.1-MindsDB-1.0')
self.connection_id = Datum('int<4>', self.proxy.connection_id)
self.scramble_1st_part = Datum('string<8>', self.proxy.salt[:8])
self.reserved_byte = Datum('string<1>', '')
self.server_capabilities_1st_part = Datum('int<2>', capabilities)
self.server_default_collation = Datum('int<1>', DEFAULT_COALLITION_ID)
self.status_flags = Datum('int<2>', SERVER_STATUS_AUTOCOMMIT)
self.server_capabilities_2nd_part = Datum('int<2>', capabilities >> 16)
self.wireshark_filler = Datum('int<1>', FILLER_FOR_WIRESHARK_DUMP)
# self.wireshark_filler = Datum('int<1>', len(self.proxy.salt))
self.reserved_filler1 = Datum('string<6>', '')
self.reserved_filler2 = Datum('string<4>', '')
self.scramble_2nd_part = Datum('string<NUL>', self.proxy.salt[8:])
self.null_close = Datum('string<NUL>', DEFAULT_AUTH_METHOD)
def setup(self):
self.cont = Datum('int<1>', 4) # 0x04
def setup(self):
self.catalog = Datum('string<lenenc>', 'def')
self.schema = Datum('string<lenenc>', self._kwargs.get('schema', ''))
self.table_alias = Datum('string<lenenc>',
self._kwargs.get('table_alias', ''))
self.table_name = Datum('string<lenenc>',
self._kwargs.get('table_name', ''))
self.column_alias = Datum('string<lenenc>',
self._kwargs.get('column_alias', ''))
self.column_name = Datum('string<lenenc>',
self._kwargs.get('column_name', ''))
self.fixed_length = Datum('int<lenenc>', 0xC)
charset = self._kwargs.get('charset',
CHARSET_NUMBERS["utf8_unicode_ci"])
self.character_set = Datum('int<2>', charset)
self.column_length = Datum(
'int<4>', self._kwargs.get('max_length', 0xf)
) # may be this? https://books.google.ru/books?id=G2YqBS9CQ0AC&lpg=PP1&hl=ru&pg=PA428#v=onepage&q&f=false
self.column_type = Datum(
'int<1>',
self._kwargs.get(
'column_type',
self._kwargs.get('column_type', TYPES.MYSQL_TYPE_VARCHAR)))
self.flags = Datum('int<2>', self._kwargs.get('flags', 0))
self.decimals = Datum('int<1>', 0)
self.unused = Datum('int<2>', 0)
