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 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 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
