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:])