def onreceive(self, event): peer = event.peer #logging.debug("[RECEIVE] Got data from %s" % (peer.address)) # check player is known by server if peer.data not in self.players: logging.warning("[RECEIVE] Packet from unknown player %s!" % (peer.address)) self.fatalerror(event.peer, "I don't know you") return player = self.players[peer.data] # shortpath if game is running if player.game is not None and player.game.state is Game.State.Running: self.call_callbacks('gamedata', event.peer, event.packet.data) return packet = None try: packet = packets.unserialize(event.packet.data) except Exception: logging.warning("[RECEIVE] Unknown packet from %s!" % (peer.address)) self.fatalerror(event.peer, "Unknown packet. Please check your game version") return # session id check if packet.sid != player.sid: logging.warning("[RECEIVE] Invalid session id for player %s (%s vs %s)!" % (peer.address, packet.sid, player.sid)) self.fatalerror(event.peer, "Invalid/Unknown session") # this will trigger ondisconnect() for cleanup return if packet.__class__ not in self.callbacks: logging.warning("[RECEIVE] Unhandled network packet from %s - Ignoring!" % (peer.address)) return self.call_callbacks(packet.__class__, event.peer, packet)
def _receive(self, timeout=SERVER_TIMEOUT): """Receive event and return unpacked packet.""" try: event = self._receive_event(timeout) if event is None or event.type != enet.EVENT_TYPE_RECEIVE: return None packet = packets.unserialize(event.packet.data) except Exception as e: try: event except NameError: pass else: self.log.error("Unknown packet from %s!" % (event.peer.address)) errstr = "Pickle/Security: %s" % (e) print("[FATAL] %s" % (errstr)) # print that even when no logger is enabled! self.log.error("[FATAL] %s" % (errstr)) self.disconnect() raise network.FatalError(errstr) if isinstance(packet, packets.cmd_error): # handle special errors here # the game got terminated by the client raise network.CommandError(packet.errorstr, type=packet.type) elif isinstance(packet, packets.cmd_fatalerror): self.log.error("[FATAL] Network message: %s" % (packet.errorstr)) self.disconnect(server_may_disconnect=True) raise network.FatalError(packet.errorstr) return [event.peer, packet]
def on_receive_data(self, event: 'enet.Event'): """ Handle received packets from the client. """ peer = event.peer if peer.data not in self.players: logging.warning("[RECEIVE] Packet from unknown player {}!".format(peer.address)) self._fatal_error(event.peer, "I don't know you") return player = self.players[peer.data] # check packet size if len(event.packet.data) > self.capabilities['maxpacketsize']: logging.warning("[RECEIVE] Global packet size exceeded from {}: size={}". format(peer.address, len(event.packet.data))) self.fatal_error(player, T("You've exceeded the global packet size.") + " " + T("This should never happen. " "Please contact us or file a bug report.")) return # shortpath if game is running if player.game and player.game.state is Game.State.Running: self.events.broadcast('gamedata', player, event.packet.data) return packet = None try: packet = packets.unserialize(event.packet.data, True, player.protocol) except network.SoftNetworkException as e: self.error(player, str(e)) return except network.PacketTooLarge as e: logging.warning("[RECEIVE] Per packet size exceeded from {}: {}". format(player, e)) self.fatal_error(player, T("You've exceeded the per packet size.") + " " + T("This should never happen. " "Please contact us or file a bug report.") + " " + str(e)) return except Exception as e: logging.warning("[RECEIVE] Unknown or malformed packet from {}: {}". format(player, e)) self.fatal_error(player, T("Unknown or malformed packet. Please check your game version")) return # session id check if packet.sid != player.sid: logging.warning( "[RECEIVE] Invalid session id for player {} ({} vs {})!". format(peer.address, packet.sid, player.sid)) self.fatal_error(player, T("Invalid/Unknown session")) return if not self.events.is_message_type_known(packet.__class__): logging.warning("[RECEIVE] Unhandled network packet from {} - Ignoring!". format(peer.address)) return self.events.broadcast(packet.__class__, player, packet)
def _receive(self, timeout=SERVER_TIMEOUT): """Receive event and return unpacked packet.""" try: event = self._receive_event(timeout) if event is None or event.type != enet.EVENT_TYPE_RECEIVE: return None packet = packets.unserialize(event.packet.data) except Exception as e: try: event except NameError: pass else: self.log.error("Unknown packet from %s!", event.peer.address) errstr = "Pickle/Security: {}".format(e) print("[FATAL] {}".format( errstr)) # print that even when no logger is enabled! self.log.error("[FATAL] %s", errstr) self.disconnect() raise network.FatalError(errstr) if isinstance(packet, packets.cmd_error): # handle special errors here # the game got terminated by the client raise network.CommandError(packet.errorstr, cmd_type=packet.type) elif isinstance(packet, packets.cmd_fatalerror): self.log.error("[FATAL] Network message: %s", packet.errorstr) self.disconnect(server_may_disconnect=True) raise network.FatalError(packet.errorstr) return [event.peer, packet]
def recv(self, timeout=SERVER_TIMEOUT): event = self._recv_event(timeout) if event is None: return None elif event.type == enet.EVENT_TYPE_RECEIVE: packet = None try: packet = packets.unserialize(event.packet.data) except Exception as e: self.log.error("Unknown packet from %s!" % (event.peer.address)) errstr = "Pickle/Security: %s" % (e) print "[FATAL] %s" % (errstr) # print that even when no logger is enabled! self.log.error("[FATAL] %s" % (errstr)) self.disconnect() raise network.FatalError(errstr) if isinstance(packet, packets.cmd_error): # handle special errors here # FIXME: it's better to pass that to the interface, # but our ui error handler currently can't handle that # the game got terminated by the client if packet.type == ErrorType.TerminateGame: game = self.game # this will destroy self.game self.leavegame(stealth=True) self.call_callbacks("lobbygame_terminate", game, packet.errorstr) return None raise network.CommandError(packet.errorstr) elif isinstance(packet, packets.cmd_fatalerror): self.log.error("[FATAL] Network message: %s" % (packet.errorstr)) self.disconnect(True) raise network.FatalError(packet.errorstr) return [event.peer, packet]
def onreceive(self, event): peer = event.peer #logging.debug("[RECEIVE] Got data from %s" % (peer.address)) # check player is known by server if peer.data not in self.players: logging.warning("[RECEIVE] Packet from unknown player {0!s}!".format(peer.address)) self._fatalerror(event.peer, "I don't know you") return player = self.players[peer.data] # check packet size if len(event.packet.data) > self.capabilities['maxpacketsize']: logging.warning("[RECEIVE] Global packet size exceeded from {0!s}: size={1!d}". format(peer.address, len(event.packet.data))) self.fatalerror(player, __("You've exceeded the global packet size.") + " " + __("This should never happen. " "Please contact us or file a bug report.")) return # shortpath if game is running if player.game is not None and player.game.state is Game.State.Running: self.call_callbacks('gamedata', player, event.packet.data) return packet = None try: packet = packets.unserialize(event.packet.data, True, player.protocol) except network.SoftNetworkException as e: self.error(player, e.message) return except network.PacketTooLarge as e: logging.warning("[RECEIVE] Per packet size exceeded from {0!s}: {1!s}". format(player, e)) self.fatalerror(player, __("You've exceeded the per packet size.") + " " + __("This should never happen. " "Please contact us or file a bug report.") + " " + str(e)) return except Exception as e: logging.warning("[RECEIVE] Unknown or malformed packet from {0!s}: {1!s}". format(player, e)) self.fatalerror(player, __("Unknown or malformed packet. Please check your game version")) return # session id check if packet.sid != player.sid: logging.warning( "[RECEIVE] Invalid session id for player {0!s} ({1!s} vs {2!s})!". format(peer.address, packet.sid, player.sid)) # this will trigger ondisconnect() for cleanup self.fatalerror(player, __("Invalid/Unknown session")) return if packet.__class__ not in self.callbacks: logging.warning("[RECEIVE] Unhandled network packet from {0!s} - Ignoring!". format(peer.address)) return self.call_callbacks(packet.__class__, player, packet)
def onreceive(self, event): #logging.debug("[RECEIVE] Got data from %s" % (event.peer.address)) packet = packets.unserialize(event.packet.data) if packet is None: logging.warning("Unknown packet from %s!" % (event.peer.address)) self.send(event.peer, packets.cmd_fatalerror("Unknown packet. Maybe old client?")) self.disconnect(event.peer, True) return if not packet.__class__ in self.callbacks: logging.warning("Unhandled network packet from %s!" % (event.peer.address)) return self.call_callbacks(packet.__class__, event.peer, packet)
def onreceive(self, event): peer = event.peer #logging.debug("[RECEIVE] Got data from %s" % (peer.address)) # check player is known by server if peer.data not in self.players: logging.warning("[RECEIVE] Packet from unknown player %s!" % (peer.address)) self._fatalerror(event.peer, "I don't know you") return player = self.players[peer.data] # check packet size if len(event.packet.data) > self.capabilities['maxpacketsize']: logging.warning("[RECEIVE] Global packet size exceeded from %s: size=%d" % (peer.address, len(event.packet.data))) self.fatalerror(player, __("You've exceeded the global packet size.") + " " + __("This should never happen. " "Please contact us or file a bug report.")) return # shortpath if game is running if player.game is not None and player.game.state is Game.State.Running: self.call_callbacks('gamedata', player, event.packet.data) return packet = None try: packet = packets.unserialize(event.packet.data, True, player.protocol) except network.SoftNetworkException as e: self.error(player, e.message) return except network.PacketTooLarge as e: logging.warning("[RECEIVE] Per packet size exceeded from %s: %s" % (player, e)) self.fatalerror(player, __("You've exceeded the per packet size.") + " " + __("This should never happen. " "Please contact us or file a bug report.") + " " + str(e)) return except Exception as e: logging.warning("[RECEIVE] Unknown or malformed packet from %s: %s!" % (player, e)) self.fatalerror(player, __("Unknown or malformed packet. Please check your game version")) return # session id check if packet.sid != player.sid: logging.warning("[RECEIVE] Invalid session id for player %s (%s vs %s)!" % (peer.address, packet.sid, player.sid)) self.fatalerror(player, __("Invalid/Unknown session")) # this will trigger ondisconnect() for cleanup return if packet.__class__ not in self.callbacks: logging.warning("[RECEIVE] Unhandled network packet from %s - Ignoring!" % (peer.address)) return self.call_callbacks(packet.__class__, player, packet)
def recv(self, timeout = SERVER_TIMEOUT): event = self.recv_event(timeout) if event is None: return None elif event.type == enet.EVENT_TYPE_RECEIVE: packet = packets.unserialize(event.packet.data) if packet is None: self.log.error("Unknown packet from %s!" % (event.peer.address)) self.disconnect() return None #elif isinstance(packet, packets.cmd_error): # raise network.CommandError(packet.errorstr) elif isinstance(packet, packets.cmd_fatalerror): self.log.error("[FATAL] Network message: %s" % (packet.errorstr)) self.disconnect() raise network.FatalError(packet.errorstr) return [event.peer, packet]
def recv(self, timeout = SERVER_TIMEOUT): event = self._recv_event(timeout) if event is None: return None elif event.type == enet.EVENT_TYPE_RECEIVE: packet = None try: packet = packets.unserialize(event.packet.data) except Exception as e: self.log.error("Unknown packet from %s!" % (event.peer.address)) errstr = "Pickle/Security: %s" % (e) print "[FATAL] %s" % (errstr) # print that even when no logger is enabled! self.log.error("[FATAL] %s" % (errstr)) self.disconnect() raise network.FatalError(errstr) if isinstance(packet, packets.cmd_error): raise network.CommandError(packet.errorstr) elif isinstance(packet, packets.cmd_fatalerror): self.log.error("[FATAL] Network message: %s" % (packet.errorstr)) self.disconnect(True) raise network.FatalError(packet.errorstr) return [event.peer, packet]
def onreceive(self, event): peer = event.peer #logging.debug("[RECEIVE] Got data from %s" % (peer.address)) # check player is known by server if peer.data not in self.players: logging.warning("[RECEIVE] Packet from unknown player %s!" % (peer.address)) self.fatalerror(event.peer, "I don't know you") return player = self.players[peer.data] # shortpath if game is running if player.game is not None and player.game.state is Game.State.Running: self.call_callbacks('gamedata', event.peer, event.packet.data) return packet = None try: packet = packets.unserialize(event.packet.data, True) except Exception, e: logging.warning("[RECEIVE] Unknown or malformed packet from %s: %s!" % (peer.address, e)) self.fatalerror(event.peer, "Unknown or malformed packet. Please check your game version") return