def __init__(self, server, writer: StreamWriter): self.remote_addr = writer.get_extra_info('peername') self.remote_host, self.remote_port = self.remote_addr self.local_addr = writer.get_extra_info('sockname') self.local_host, self.local_port = self.local_addr self.server = server self.writer = writer # state self.registered = False self.nickname = None self.user = None self.realname = None self.vhost = None
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): temp_ref = TempRef() world_packet_manager = WorldPacketManager(temp_ref=temp_ref, reader=reader, writer=writer) peername = writer.get_extra_info('peername') Logger.debug('[World Server]: Accept connection from {}'.format(peername)) Logger.info('[World Server]: trying to process auth session') auth = AuthManager(reader, writer, temp_ref=temp_ref, world_packet_manager=world_packet_manager) await auth.process(step=AuthStep.SECOND) self._register_tasks() while True: try: request = await asyncio.wait_for(reader.read(4096), timeout=1.0) if request: response = await asyncio.wait_for(world_packet_manager.process(request), timeout=1.0) if response: for packet in response: writer.write(packet) await writer.drain() except TimeoutError: continue except Exception as e: Logger.error('[World Server]: exception, {}'.format(e)) traceback.print_exc() break writer.close()
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): peername = writer.get_extra_info('peername') Logger.info('[Login Server]: Accepted connection from {}'.format(peername)) temp_ref = TempRef() auth = AuthManager(reader, writer, temp_ref=temp_ref) await auth.process(step=AuthStep.FIRST) writer.close()
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): self._register_tasks() temp_ref = TempRef() world_packet_manager = WorldPacketManager(temp_ref=temp_ref, reader=reader, writer=writer) Logger.info('[World Server]: trying to process auth session') auth = AuthManager(reader, writer, temp_ref=temp_ref, world_packet_manager=world_packet_manager, session_keys=self.session_keys) is_authenticated = await auth.process(step=AuthStep.SECOND) if is_authenticated: peer_name = writer.get_extra_info('peername') Logger.success( '[World Server]: Accept connection from {}'.format(peer_name)) while True: try: request = await asyncio.wait_for(reader.read(4096), timeout=0.01) if request: response = await asyncio.wait_for( world_packet_manager.process(request), timeout=0.01) if response: for packet in response: writer.write(packet) await writer.drain() except TimeoutError: pass except BrokenPipeError: pass except Exception as e: Logger.error('[World Server]: exception, {}'.format(e)) traceback.print_exc() break finally: await asyncio.sleep(0.01) writer.close()
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): peername = writer.get_extra_info('peername') Logger.info( '[Login Server]: Accepted connection from {}'.format(peername)) auth = AuthManager(reader, writer) while not reader.at_eof(): response = await auth.process() if not response: break Logger.warning('[Login Server]: closing...') writer.close()
async def make_client(reader: StreamReader, writer: StreamWriter): # get peer name peer_name = writer.get_extra_info(PEER_NAME) print(f"Recieved request for peer: {peer_name}") # get subscriber channel and add to list subscriber_chan = await read_msg(reader) # adding this writer to subscriber list as well SUBSCRIBER_LIST[subscriber_chan].append(writer) # spawn a async task for this writer to pull msgs off to queue and send to subscribers asyncio.create_task(msg_writer(writer, SEND_QUEUE[writer])) try: while True: chan = await read_msg(reader) if chan not in CHAN_QUEUE: # create a queue where we will enqueue msgs for given channel CHAN_QUEUE[chan] = Queue(maxsize=CHAN_QUEUE_SIZE) # spawn up new channel sender asyncio.create_task(channel_sender(chan)) data = await read_msg(reader) """ put the msg onto the queue for this channel channel sender will pull msg off this queue and then put it in the respective writers queues """ await CHAN_QUEUE[chan].put(data) except asyncio.CancelledError: print(f"remote peer closing : {peer_name}") writer.close() await writer.wait_closed() except asyncio.IncompleteReadError: print(f"remote peer {peer_name} disconnected") finally: print(f"remote peer {peer_name} closed") # remove our writer form channel list SUBSCRIBER_LIST[subscriber_chan].remove(writer) # close async task for this writer await SEND_QUEUE[writer].put(None)
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): peername = writer.get_extra_info('peername') Logger.info( '[Login Server]: Accepted connection from {}'.format(peername)) connection = Connection(reader=reader, writer=writer, peername=peername) world_packet_mgr = WorldPacketManager(connection=connection) while True: try: await LoginServer.process_request(reader, writer, world_packet_mgr) except TimeoutError: continue finally: await asyncio.sleep(Config.Realm.Settings.min_timeout)
async def handle_connection(self, reader: StreamReader, writer: StreamWriter): peername = writer.get_extra_info('peername') Logger.debug( '[World Server]: Accept connection from {}'.format(peername)) await self.accept_connection(peername) auth = AuthSessionManager(reader, writer) auth.prepare() await auth.process() # If I understand it correctly, after SMSG_AUTH_RESPONSE server should waiting for CMSG_CHAR_ENUM # But next request never sends by client. Client stucks on 'Connected' try: next_request = await asyncio.wait_for(reader.read(1024), timeout=1.0) Logger.debug( '[World Server]: next request = {}'.format(next_request)) except TimeoutError: Logger.error('[World Server]: next request was not received') finally: Logger.warning('[World Server]: closing...')
async def initial_connection_check(self, reader: StreamReader, writer: StreamWriter): host_port = writer.get_extra_info('peername') new_user: Optional[User] = None try: # 1. send plain message writer.write(b'hello') await writer.drain() # 2. receive other's header try: received = await asyncio.wait_for(reader.read(BUFFER_SIZE), 5.0) if len(received) == 0: raise PeerToPeerError('empty msg receive') header = json.loads(received.decode()) except asyncio.TimeoutError: raise PeerToPeerError('timeout on other\'s header receive') except json.JSONDecodeError: raise PeerToPeerError( 'json decode error on other\'s header receive') # 3. generate new user user_header = UserHeader(**header) new_user = User(user_header, self.number, reader, writer, host_port, AESCipher.create_key(), SERVER_SIDE) self.number += 1 if new_user.header.name == V.SERVER_NAME: raise ConnectionAbortedError('Same origin connection') # 4. send my public key my_sec, my_pub = generate_keypair() send = json.dumps({'public-key': my_pub}).encode() await new_user.send(send) self.traffic.put_traffic_up(send) # 5. receive public key try: receive = await new_user.recv() self.traffic.put_traffic_down(receive) if len(receive) == 0: raise ConnectionAbortedError('received msg is zero.') data = json.loads(receive.decode()) except asyncio.TimeoutError: raise PeerToPeerError('timeout on public key receive') except json.JSONDecodeError: raise PeerToPeerError( 'json decode error on public key receive') # 6. encrypt and send AES key and header send = json.dumps({ 'aes-key': new_user.aeskey, 'header': self.get_server_header(), }) key = generate_shared_key(my_sec, data['public-key']) encrypted = AESCipher.encrypt(key, send.encode()) await new_user.send(encrypted) self.traffic.put_traffic_up(encrypted) # 7. receive accept signal try: encrypted = await new_user.recv() self.traffic.put_traffic_down(encrypted) except asyncio.TimeoutError: raise PeerToPeerError('timeout on accept signal receive') receive = AESCipher.decrypt(new_user.aeskey, encrypted) if receive != b'accept': raise PeerToPeerError(f"Not accept signal! {receive}") # 8. accept connection log.info( f"established connection as server from {new_user.header.name} {new_user.get_host_port()}" ) asyncio.ensure_future(self.receive_loop(new_user)) # server port's reachable check await asyncio.sleep(1.0) await self.check_reachable(new_user) return except (ConnectionAbortedError, ConnectionResetError) as e: msg = f"disconnect error {host_port} {e}" except PeerToPeerError as e: msg = f"peer2peer error {host_port} {e}" except Exception as e: msg = "InitialConnCheck: {}".format(e) log.error(msg, exc_info=True) # EXCEPTION! if new_user: # remove user self.remove_connection(new_user, msg) else: # close socket log.debug(msg) try: writer.write(msg.encode()) await writer.drain() except Exception: pass try: writer.close() except Exception: pass
def new_client(self, reader: StreamReader, writer: StreamWriter): addr = writer.get_extra_info('peername') clnt = client.Client(self, writer) asyncio. async (self.protocol_handler(reader, clnt)) yield from self.queue.put((EVENT_NEW_CLIENT, clnt))