def isAuthOk(self, user, orig_user, password, orig_password):
try:
if user != orig_user:
log.warning(f'Check auth, user={user}: user mismatch')
return False
if password != orig_password:
log.warning(f'check auth, user={user}: password mismatch')
return False
self.session.username = user
self.session.auth = True
log.info(f'Check auth, user={user}: Ok')
return True
except Exception:
log.error(f'Check auth, user={user}: ERROR')
log.error(traceback.format_exc())
def fetch(self, datahub):
try:
self.datahub = datahub
self._fetchData()
data = self._processData()
self.result = self._makeResultVeiw(data)
except (TableWithoutDatasourceException, UndefinedColumnTableException,
DuplicateTableNameException, NotImplementedError, SqlError,
Exception) as e:
# TODO determine different codes for errors types
log.error(f'ERROR while fetching data for query: {self.raw}\n'
f'{traceback.format_exc()}\n'
f'{e}')
return {
'success': False,
'error_code': ERR.ER_SYNTAX_ERROR,
'msg': str(e)
}
return {'success': True, 'result': self.result}
def setFromBuff(self, buff):
val = ''
start = 0
if self.var_len == 'lenenc':
start = 1
ln_enc = buff[0]
if int(ln_enc) <= ONE_BYTE_ENC[0]:
start = 0
end = 1
elif int(ln_enc) == TWO_BYTE_ENC[0]:
end = 3
elif int(ln_enc) == THREE_BYTE_ENC[0]:
end = 4
elif ln_enc:
end = 9
num_str = buff[start:end]
if end > 9:
log.error('Cant decode integer greater than 8 bytes')
return buff[end - 1:]
for j in range(8 - (start - end)):
num_str += b'\0'
if self.var_type == 'int':
self.value = struct.unpack('i', num_str)
return buff[end:]
if self.var_type in ['byte', 'string']:
length = struct.unpack('i', num_str)
self.value = buff[start:(length + end)]
return buff[(length + end):]
if self.var_len == 'EOF':
length = len(buff)
self.var_len = str(length)
self.value = buff
return ''
else:
length = self.var_len
if self.type == 'string<NUL>':
for j, x in enumerate(buff):
if int(x) == 0:
length = j + 1
break
length = int(length)
if self.var_type in ['byte', 'string']:
end = length
self.value = buff[:end]
else: # if its an integer
end = length
num_str = buff[:end]
if end > 8:
log.error('cant decode integer greater than 8 bytes')
return buff[end:]
for j in range(8 - end):
num_str += b'\0'
self.value = struct.unpack('Q', num_str)[0]
if str(self.var_len) == 'NUL':
self.value = self.value[:-1]
return buff[end:]
def handle(self):
"""
Handle new incoming connections
:return:
"""
log.info('handle new incoming connection')
if self.handshake() is False:
return
while True:
log.debug('Got a new packet')
p = self.packet(CommandPacket)
try:
success = p.get()
except Exception:
log.warning('Session closed, on packet read error')
log.debug(traceback.format_exc())
# self.server.shutdown()
return
if success is False:
log.info('Session closed by client')
# self.server.shutdown()
return
log.info('Command TYPE: {type}'.format(
type=getConstName(COMMANDS, p.type.value)))
if p.type.value == COMMANDS.COM_QUERY:
try:
sql = p.sql.value.decode('utf-8')
# NOTE dbeaver can insert in start of query comment with connector version, for example
# /* mysql-connector-java-8.0.11 (Revision: 6d4eaa273bc181b4cf1c8ad0821a2227f116fedf) */SELECT @@session.auto_increment_increment
sql = re.sub(re.compile("/\*.*?\*/", re.DOTALL), "", sql)
sql = sql.strip(' ;')
except Exception:
log.error('SQL contains non utf-8 values: {sql}'.format(sql=p.sql.value))
self.packet(OkPacket).send()
continue
log.info(f'COM_QUERY: {sql}')
self.current_transaction = self.session.newTransaction(sql_query=sql)
try:
self.queryAnswer(sql)
except Exception as e:
log.error(
f'ERROR while executing query: {sql}\n'
f'{traceback.format_exc()}\n'
f'{e}'
)
self.packet(
ErrPacket,
err_code=ERR.ER_SYNTAX_ERROR,
msg=str(e)
).send()
# if self.current_transaction.output_data_array is None:
# self.packet(OkPacket).send()
# else:
# self.packet(ResultsetPacket, metadata=self.current_transaction.output_metadata,
# data_array=self.current_transaction.output_data_array).send()
elif p.type.value == COMMANDS.COM_QUIT:
log.info('Session closed, on client disconnect')
self.session = None
break
else:
log.info('Command has no specific handler, return OK msg')
log.debug(str(p))
# p.pprintPacket() TODO: Make a version of print packet
# that sends it to debug isntead
self.packet(OkPacket).send()