def datagram_received(self, data, addr):
try:
data, key, iv = cryptor.decrypt_all(self._password, self._method,
data)
except Exception:
logger.debug('UDP handle_server: decrypt data failed')
return
if not data:
logger.debug('UDP handle_server: data is empty after decrypt')
return
header_result = common.parse_header(data)
if header_result is None:
logger.error(
"can not parse header when handling connection from {0}".
format(addr))
return
addrtype, remote_addr, remote_port, header_length = header_result
logger.info("udp data to {0}:{1} from {2}:{3}".format(
remote_addr, remote_port, addr[0], addr[1]))
client_key = "{0}:{1}".format(addr[0], addr[1])
remote = self._sessions.get(client_key, None)
if not remote:
remote = RelayRemoteProtocol(self, addr)
self._sessions[client_key] = remote
self._loop.create_task(
self.create_endpoint(remote, common.to_str(remote_addr),
remote_port))
data = data[header_length:]
remote.write(data)
def datagram_received(self, data, addr):
# addr = ip, port
packet = PublishPacket.decode(data)
if packet is not None:
try:
data, key, iv = cryptor.decrypt_all(self._password,
self._method, packet.data)
except Exception:
logger.debug('UDP handle_server: decrypt data failed')
return
if not data:
logger.debug('UDP handle_server: data is empty after decrypt')
return
header_result = common.parse_header(data)
if header_result is None:
logger.error(
"can not parse header when handling connection from {}".
format(addr))
return
addrtype, remote_addr, remote_port, header_length = header_result
logger.info("udp data to {}:{} from {}:{}".format(
remote_addr, remote_port, addr[0], addr[1]))
remote = self._topic_to_remote.get(packet.topic_id)
if not remote:
remote = RelayRemoteProtocol(self, packet.topic_id, addr)
self._topic_to_remote[packet.topic_id] = remote
self._loop.create_task(
self.create_endpoint(remote, common.to_str(remote_addr),
remote_port))
data = data[header_length:]
remote.write(data)
def data_received(self, data):
# self._last_activity = self._loop.time()
# verify packet
data = self._encryptor.decrypt(data)
if not self._address_parsed:
header_result = common.parse_header(data)
if header_result is None:
logging.error("Can not parse header when handling client connection{0}".format(self._peername))
self.close(force=True)
return
addrtype, remote_addr, remote_port, header_length = header_result
self._address_parsed = True
self._mqtt_client.write(data, self._topic)
def datagram_received(self, data, addr):
# addr = ip, port
try:
data, key, iv = cryptor.decrypt_all(self._password, self._method,
data)
except Exception:
logger.debug('UDP handle_server: decrypt data failed')
return
header_result = common.parse_header(data)
if header_result is None:
logger.error(
"can not parse header when handling connection from {}".format(
addr))
return
addrtype, remote_addr, remote_port, header_length = header_result
self._mqtt_client.write(data, addr)
def handle_publish(self, publish_packet: PublishPacket):
if not self._approved:
self._loop.create_task(self.stop())
return
data = bytes(publish_packet.data)
remote = self._topic_to_remote.get(publish_packet.topic_name, None)
if not publish_packet.retain_flag:
data = self._encryptor.decrypt(data)
if remote is None: # we are in STAGE_ADDR
if not data:
self._write_eof(publish_packet.topic_name)
return
header_result = common.parse_header(data)
if header_result is None:
logging.error(
"Can not parse header when handling mqtt client({}) connection{}."
.format(publish_packet.topic_name, self._peername))
self._write_eof(publish_packet.topic_name)
return
addrtype, remote_addr, remote_port, header_length = header_result
logging.info(
"Connecting to remote {}:{} from mqtt client({}) connection{}."
.format(common.to_str(remote_addr), remote_port,
publish_packet.topic_name, self._peername))
remote = RelayRemoteProtocol(self._loop, self,
publish_packet.topic_name)
self._topic_to_remote[publish_packet.topic_name] = remote
self._loop.create_task(
self.create_connection(remote, common.to_str(remote_addr),
remote_port))
if len(data) > header_length:
remote.write(data[header_length:])
else: # now in STAGE_STREAM
remote.write(data)
else:
if remote is not None:
remote.close(force=True)
def datagram_received(self, data, addr):
packet = PublishPacket.decode(data)
if packet is not None:
try:
data, key, iv = cryptor.decrypt_all(self._password,
self._method, packet.data)
except Exception:
logger.debug('UDP handle_server: decrypt data failed')
return
header_result = common.parse_header(data)
if header_result is None:
logger.error(
"can not parse header when handling publish packet from server: {}"
.format(addr))
return
addr = self._udpsession_lru.topic_to_addr(packet.topic_id)
if addr is not None and self._server is not None:
self._server.write(data, addr)
self._last_activity = self._loop.time()
def handle_stage_addr(self, data):
header_result = common.parse_header(data)
if header_result is None:
logger.error(
"can not parse header when handling connection from {0}:{1}".
format(self._peername[0], self._peername[1]))
self._transport.close()
return
addrtype, remote_addr, remote_port, header_length = header_result
logger.info('connecting to %s:%d from %s:%d' %
(common.to_str(remote_addr), remote_port,
self._peername[0], self._peername[1]))
self._remote = RelayRemoteProtocol(self)
self._loop.create_task(
self.create_connection(common.to_str(remote_addr), remote_port))
self._stage = STAGE_STREAM
if len(data) > header_length:
self._remote.write(data[header_length:])