def toggleParticipate_4363(self, pkt):
participate = (struct.unpack('!B', pkt.data[0:1])[0] == 1)
room = self._user.state.room
packetPayload = b'\0\0\0\0' # success
if room:
if participate:
# check roster-hash match with host
rosterHashMismatch = False
if room.participatingPlayers:
gameHost = room.participatingPlayers[0]
rosterHashMismatch = (
room.lobby.checkRosterHash
and not self.checkHashes(gameHost, self._user))
if rosterHashMismatch:
packetPayload = b'\0\0\0\1'
text = ('Roster mismatch: %s vs %s. '
'Player %s cannot participate.' %
(gameHost.profile.name, self._user.profile.name,
self._user.profile.name))
log.msg(text)
self.broadcastRoomChat(room, text.encode('utf-8'))
elif room.isForcedCancelledParticipation(self._user):
packetPayload = b'\xff\xff\xfd\xb6' # still cancelled
else:
room.participate(self._user)
else:
room.cancelParticipation(self._user)
# share participation status with players in room
data = self.formatRoomParticipationStatus(room)
for player in room.players:
player.sendData(0x4365, data)
data = b'%s%s%s' % (packetPayload, struct.pack('!B', participate),
struct.pack('!B',
room.getPlayerParticipate(self._user)))
self.sendData(0x4364, data)
def deleteRoom(self, room):
try:
del self.rooms[room.name]
log.msg('Room(id=%d, name=%s) destroyed' % (
room.id, room.name))
except KeyError:
pass
def connectionLost(self, reason):
log.debug('Connection lost: %s' % reason.getErrorMessage())
if self.factory.serverConfig.Debug:
try:
log.debug('Traceback: %s' % reason.getTraceback())
except:
log.msg('Could not log traceback')
def recordMatchResult(self, room):
match = room.match
duration = datetime.now() - match.startDatetime
log.msg('MATCH FINISHED: '
'Team %d (%s) - Team %d (%s) %d:%d. '
'Match time: %s.' % (
match.teamSelection.home_team_id, getHomePlayerNames(match),
match.teamSelection.away_team_id, getAwayPlayerNames(match),
match.score_home, match.score_away,
duration))
# check if match result should be stored
thisLobby = self.factory.getLobbies()[
self._user.state.lobbyId]
if thisLobby.typeCode != 0x20: # no-stats
# record the match in DB
yield self.factory.matchData.store(match)
participants = [match.teamSelection.home_captain,
match.teamSelection.away_captain]
participants.extend(match.teamSelection.home_more_players)
participants.extend(match.teamSelection.away_more_players)
for profile in participants:
# update player play time
profile.playTime += duration
# re-calculate points
stats = yield self.getStats(profile.id)
rm = self.factory.ratingMath
profile.points = rm.getPoints(stats)
# store updated profile
yield self.factory.storeProfile(profile)
else:
yield defer.succeed(None)
def matchStateUpdate_4377(self, pkt):
state = struct.unpack('!B', pkt.data[0])[0]
room = self._user.state.room
if not room or not room.teamSelection:
log.msg(
'ERROR: got match state update, '
'but no room or team-selection')
else:
if room.match is not None:
room.match.state = state
# check if match just started
if state == lobby.MatchState.FIRST_HALF:
match = lobby.Match6(room.teamSelection)
log.msg('NEW MATCH started: Team %d (%s) vs Team %d (%s)' % (
room.teamSelection.home_team_id,
getHomePlayerNames(room),
room.teamSelection.away_team_id,
getAwayPlayerNames(room)))
match.startDatetime = datetime.now()
match.home_team_id = match.teamSelection.home_team_id
match.away_team_id = match.teamSelection.away_team_id
room.match = match
room.match.state = state
# check if match is done
elif state == lobby.MatchState.FINISHED and room.match:
room.phase = lobby.RoomState.ROOM_MATCH_FINISHED
self.recordMatchResult(room)
# let others in the lobby know
self.sendRoomUpdate(room)
self.sendZeros(0x4378, 4)
def sendData(self, packetId, data):
if self.lobbyConnection is None:
log.msg(
'WARN: Cannot send data to user {%s}: '
'no lobby connection' % self.hash)
else:
self.lobbyConnection.sendData(packetId, data)
def _failed(error):
log.msg('ERROR: %s' % str(error.value))
request.setResponseCode(500)
request.write(
self.sendResponse(fmt, request,
'ERROR: Unable to register: server errror'))
request.finish()
def getHomeOrAway(self, usr):
# try:
# log.msg('usr.profile.id=%s' % usr.profile.id)
#if (self.home_captain is None):
#log.msg('self.home_captain is None')
#else:
#log.msg('self.home_captain.id=%s' % self.home_captain.id)
#if (self.away_captain is None):
#log.msg('self.away_captain is None')
#else:
#log.msg('self.away_captain.id=%s' % self.away_captain.id)
#except:
# log.msg("Error logging in getHomeOrAway: %s" % sys.exc_info()[0])
# exc_type, exc_value, exc_traceback = sys.exc_info()
# lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
# log.msg("Lines: %s" % lines)
try:
if ((self.home_captain is not None and (usr.profile.id == self.home_captain.id)) or
any(prof for prof in self.home_more_players
if prof.id == usr.profile.id)):
#log.msg('returning 0x00')
return 0x00
if ((self.away_captain is not None and (usr.profile.id == self.away_captain.id)) or
any(prof for prof in self.away_more_players
if prof.id == usr.profile.id)):
#log.msg('returning 0x01')
return 0x01
except:
log.msg("Error in getHomeOrAway: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
#log.msg('returning 0xff')
return 0xff
def connectionLost(self, reason):
log.debug('Connection lost: %s' % reason.getErrorMessage())
if self.factory.serverConfig.Debug:
try:
log.debug('Traceback: %s' % reason.getTraceback())
except:
log.msg('Could not log traceback')
def deleteRoom(self, room):
try:
del self.rooms[room.name]
log.msg('Room(id=%d, name=%s) destroyed' % (
room.id, room.name))
except KeyError:
pass
def cancelParticipation(self, usr):
try:
self.participatingPlayers.pop(self.participatingPlayers.index(usr))
except ValueError:
log.msg('WARN player (%s) is cancelling participation, '
'but was not among participants.' % (usr.profile.name))
return 0xff
def exitRoom_432a(self, pkt):
if self._user.state.inRoom == 0:
log.msg('WARN: user not in a room.')
self.sendZeros(0x432b,4)
else:
return self.exitingRoom(
self._user.state.room, self._user)
def deleteUser(self, username):
results = yield self.userData.findByUsername(username)
if not results:
raise Exception('Unknown username: %s' % username)
usr = results[0]
yield self.userData.delete(usr)
log.msg('User "%s" has been DELETED.' % username)
defer.returnValue(usr)
def renderError(self, error, request, responseCode=500):
request.setHeader('Content-Type', 'text/xml')
request.setResponseCode(responseCode)
log.msg('SERVER ERROR: %s' % str(error.value))
request.write(
('%s<error text="server error" href="/home">'
'<details>%s</details>'
'</error>' % (XML_HEADER, str(error.value))).encode('utf-8'))
request.finish()
def isSameGame(factory, userA, userB):
aInfo = factory.getUserInfo(userA)
bInfo = factory.getUserInfo(userB)
result = (userA.gameVersion == userB.gameVersion
and aInfo.gameName == bInfo.gameName)
if not result:
log.msg('INFO: Game versions differ: %s(%s,%s) != %s(%s,%s). ' %
(userA.profile.name, userA.gameVersion, aInfo.gameName,
userB.profile.name, userB.gameVersion, bInfo.gameName))
return result
def joinRoom_4320(self, pkt):
roomId = struct.unpack('!i', pkt.data[0:4])[0]
thisLobby = self.factory.getLobbies()[self._user.state.lobbyId]
room = thisLobby.getRoomById(roomId)
if room is None:
log.msg('ERROR: Room (id=%d) does not exist.' % roomId)
self.sendData(0x4321, b'\0\0\0\1')
else:
if room.usePassword:
enteredPassword = util.stripZeros(pkt.data[4:19])
if enteredPassword != room.password:
log.msg('ERROR: Room (id=%d) password does not match.' %
roomId)
self.sendData(0x4321, b'\xff\xff\xfd\xda')
else:
room.enter(self._user)
else:
room.enter(self._user)
self.sendRoomUpdate(room)
self.sendPlayerUpdate(room.id)
data = b'\0\0\0\0'
if room.matchSettings:
data += room.matchSettings.match_time
self.sendData(0x4321, data)
# give players in room stun of joiner
# special 4330 packet
self.do_4330(room)
# give joiner stun of players in room
self.sendZeros(0x4346, 0)
for otherUsr in room.players:
if otherUsr == self._user:
continue
data = (b'%(pad1)s%(ip1)s%(port1)s'
b'%(ip2)s%(port2)s%(id)s'
b'%(someField)s%(participate)s') % {
b'pad1':
b'\0' * 32,
b'ip1':
util.padWithZeros(otherUsr.state.ip1, 16),
b'port1':
struct.pack('!H', otherUsr.state.udpPort1),
b'ip2':
util.padWithZeros(otherUsr.state.ip2, 16),
b'port2':
struct.pack('!H', otherUsr.state.udpPort2),
b'id':
struct.pack('!i', otherUsr.profile.id),
b'someField':
struct.pack('!H', 0),
b'participate':
struct.pack('!B', room.getPlayerParticipate(otherUsr)),
}
self.sendData(0x4347, data)
self.sendZeros(0x4348, 0)
def renameRoom(self, room, newName):
try:
del self.rooms[room.name]
oldName, room.name = room.name, newName
self.rooms[room.name] = room
log.msg('Room(id=%d, name=%s) was renamed to: %s' % (
room.id, oldName, room.name))
except KeyError:
log.msg('Room(id=%d, name=%s) cannot be renamed. '
'This lobby does not know anything about it' % (
room.id, room.name))
def renameRoom(self, room, newName):
try:
del self.rooms[room.name]
oldName, room.name = room.name, newName
self.rooms[room.name] = room
log.msg('Room(id=%d, name=%s) was renamed to: %s' % (
room.id, oldName, room.name))
except KeyError:
log.msg('Room(id=%d, name=%s) cannot be renamed. '
'This lobby does not know anything about it' % (
room.id, room.name))
def chat_4400(self, pkt):
thisLobby = self.factory.getLobbies()[self._user.state.lobbyId]
chatType = pkt.data[0:2]
message = util.stripZeros(pkt.data[10:])
data = '%s%s%s%s%s' % (
chatType,
pkt.data[2:6],
struct.pack('!i',self._user.profile.id),
util.padWithZeros(self._user.profile.name,48),
#util.padWithZeros(message, 128))
message[:126]+'\0\0')
if chatType=='\x00\x01':
# add to lobby chat history
thisLobby.addToChatHistory(
lobby.ChatMessage(self._user.profile, message))
# lobby chat
for usr in thisLobby.players.itervalues():
usr.sendData(0x4402, data)
elif chatType=='\x01\x08':
# room chat
room = self._user.state.room
if room:
for usr in room.players:
usr.sendData(0x4402, data)
elif chatType=='\x00\x02':
# private message
profileId = struct.unpack('!i',pkt.data[6:10])[0]
usr = thisLobby.getPlayerByProfileId(profileId)
if usr:
# add to lobby chat history
thisLobby.addToChatHistory(
lobby.ChatMessage(
self._user.profile, message, usr.profile,
pkt.data[2:6]))
usr.sendData(0x4402, data)
if usr != self._user:
self._user.sendData(0x4402, data) # echo to self
else:
log.msg(
'WARN: user with profile id = '
'%d not found.' % profileId)
elif chatType=='\x01\x05':
# match chat
room = self._user.state.room
if room:
for usr in room.players:
usr.sendData(0x4402, data)
elif chatType=='\x01\x07':
# stadium chat
room = self._user.state.room
if room:
for usr in room.players:
usr.sendData(0x4402, data)
def setOwner_4349(self, pkt):
newOwnerProfileId = struct.unpack('!i',pkt.data[0:4])[0]
thisLobby = self.factory.getLobbies()[self._user.state.lobbyId]
room = self._user.state.room
if room:
usr = thisLobby.getPlayerByProfileId(newOwnerProfileId)
if not usr:
log.msg('WARN: player %s cannot become owner: not in the room.')
else:
room.setOwner(usr)
self.sendRoomUpdate(room)
self.sendZeros(0x434a,4)
def isSameGame(factory, userA, userB):
aInfo = factory.getUserInfo(userA)
bInfo = factory.getUserInfo(userB)
result = (userA.gameVersion == userB.gameVersion and
aInfo.gameName == bInfo.gameName)
if not result:
log.msg('INFO: Game versions differ: %s(%s,%s) != %s(%s,%s). ' % (
userA.profile.name, userA.gameVersion,
aInfo.gameName,
userB.profile.name, userB.gameVersion,
bInfo.gameName))
return result
def getPoolItem(self):
if 0 == len(self._items):
log.msg('WARN: item requested from an empty pool')
raise Exception()
sumWeight = 0
for item in self._items:
sumWeight += item.getWeight()
n = uniform(0, sumWeight)
for item in self._items:
if n < sumWeight:
break
n = n - item.getWeight()
return item
def goalScored_4375(self, pkt):
room = self._user.state.room
if not room.match:
log.msg('ERROR: Goal reported, but no match in the room.')
else:
if pkt.data[0] == '\0':
log.msg('GOAL SCORED by HOME team %d (%s)' % (
room.teamSelection.home_team_id,
getHomePlayerNames(room.match)))
room.match.goalHome()
else:
log.msg('GOAL SCORED by AWAY team %d (%s)' % (
room.teamSelection.away_team_id,
getAwayPlayerNames(room.match)))
room.match.goalAway()
log.msg(
'UPDATE: Team %d (%s) vs Team %d (%s) - %d:%d (in progress)' % (
room.teamSelection.home_team_id,
getHomePlayerNames(room.match),
room.teamSelection.away_team_id,
getAwayPlayerNames(room.match),
room.match.score_home, room.match.score_away))
self.sendZeros(0x4376, 4)
# let others in the lobby know
self.sendRoomUpdate(room)
def teamSelected_4373(self, pkt):
team = struct.unpack('!H', pkt.data[0:2])[0]
log.msg('Team selected: %d' % team)
room = self._user.state.room
if not room.teamSelection:
log.msg('ERROR: room has no TeamSelection object')
else:
ts = room.teamSelection
if self._user.profile.id == ts.home_captain.id:
ts.home_team_id = team
elif self._user.profile.id == ts.away_captain.id:
ts.away_team_id = team
self.sendData(0x4374,'\0\0\0\0')
self.sendRoomUpdate(room)
def relayRoomSettings_4350(self, pkt):
if not self._user.state:
return
room = self._user.state.room
if room:
if pkt.data[0:4] == '\0\0\1\3': #TODO clean this up (3 - phase?)
# extract info that we care about
room.matchTime = 5*(ord(pkt.data[12]) + 1)
log.msg('match time set to: %d minutes' % room.matchTime)
# send to others
for usr in self._user.state.room.players:
if usr == self._user:
continue
usr.sendData(0x4350, pkt.data)
def exit(self, usr):
usr.state.inRoom = 0
usr.state.noLobbyChat = 0
usr.state.room = None
try:
exiting = self.players.pop(self.getPlayerPosition(usr))
except ValueError:
log.msg('WARN: player (%s) exiting, but was not in the room' %
(usr.profile.name))
else:
if self.isOwner(exiting):
# owner is exiting: assign new owner, if anybody
# is still left in the room.
if self.players:
self.setOwner(self.players[0])
def enter(self, usr):
try:
log.debug('Room.enter: profiles=%s' % ','.join([x.name for x in usr.profiles]))
log.debug('Room.enter: self.name=%s' % self.name)
except:
log.msg('ERROR logging Room.enter')
usr.state.inRoom = 1
usr.state.room = self
usr.state.spectator = 0
usr.state.timeCancelledParticipation = None
if not self.players:
self.owner = usr
self.players.append(usr)
def __str__(self):
resStr = ""
try:
resStr = ('Match (clock=%s)' % self.clock)
if self.teamSelection:
resStr += (' (self.teamSelection.home_captain.name=%s)' % self.teamSelection.home_captain.name)
resStr += (' (self.teamSelection.away_captain.name=%s)' % self.teamSelection.away_captain.name)
resStr += (' (scoreHome=%s)' % self.getScoreHome())
resStr += (' (scoreAway=%s)' % self.getScoreAway())
except:
log.msg("Error in __str__: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
return resStr
def matchClockUpdate_4385(self, pkt):
clock = struct.unpack('!B', pkt.data[0:1])[0]
room = self._user.state.room
if not room or not room.match:
log.msg('ERROR: got clock update, but no match')
else:
room.match.clock = clock
log.msg(
'CLOCK: Team %d (%s) vs Team %d (%s). Minute: %d' %
(room.teamSelection.home_team_id, getHomePlayerNames(
room.match), room.teamSelection.away_team_id,
getAwayPlayerNames(room.match), room.match.clock))
self.sendZeros(0x4386, 4)
# let others in the lobby know
self.sendRoomUpdate(room)
def enter(self, usr):
try:
log.debug('Room.enter: profiles=%s' %
','.join([x.name for x in usr.profiles]))
log.debug('Room.enter: self.name=%s' % self.name)
except:
log.msg('ERROR logging Room.enter')
usr.state.inRoom = 1
usr.state.room = self
usr.state.spectator = 0
usr.state.timeCancelledParticipation = None
if not self.players:
self.owner = usr
self.players.append(usr)
def dataReceived(self, data):
try:
self.resetTimeout()
self._recvd += data
while len(self._recvd) >= 8:
hdr = packet.makePacketHeader(stream.xorData(self._recvd[:8], 0))
if len(self._recvd) < hdr.length + 24:
break
pkt = packet.makePacket(
stream.xorData(self._recvd[:hdr.length + 24], 8))
self._recvd = self._recvd[hdr.length + 24:]
self._packetReceived(pkt)
except:
log.msg("ERROR in ___init___.py:PacketReceiver.dataReceived: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
def connectionMade(self):
try:
self.transport.setTcpKeepAlive(1)
except:
log.msg("Error in protocol.connectionMade: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
log.msg('[RECV {%s}]: %s' % (username, PacketFormatter.format(pkt)))
try:
PacketReceiver.connectionMade(self)
self._handlers = dict()
self.register()
except:
log.msg("Error in protocol.connectionMade: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
def __str__(self):
resStr = ""
try:
resStr = ('Match (clock=%s)' % self.clock)
if self.teamSelection:
resStr += (' (self.teamSelection.home_captain.name=%s)' %
self.teamSelection.home_captain.name)
resStr += (' (self.teamSelection.away_captain.name=%s)' %
self.teamSelection.away_captain.name)
resStr += (' (scoreHome=%s)' % self.getScoreHome())
resStr += (' (scoreAway=%s)' % self.getScoreAway())
except:
log.msg("Error in __str__: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value,
exc_traceback)
log.msg("Lines: %s" % lines)
return resStr
def dataReceived(self, data):
try:
self.resetTimeout()
self._recvd += data
while len(self._recvd) >= 8:
hdr = packet.makePacketHeader(
stream.xorData(self._recvd[:8], 0))
if len(self._recvd) < hdr.length + 24:
break
pkt = packet.makePacket(
stream.xorData(self._recvd[:hdr.length + 24], 8))
self._recvd = self._recvd[hdr.length + 24:]
self._packetReceived(pkt)
except:
log.msg("ERROR in ___init___.py:PacketReceiver.dataReceived: %s" %
sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value,
exc_traceback)
log.msg("Lines: %s" % lines)
def connectionMade(self):
try:
self.transport.setTcpKeepAlive(1)
except:
log.msg("Error in protocol.connectionMade: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value,
exc_traceback)
log.msg("Lines: %s" % lines)
log.msg('[RECV {%s}]: %s' %
(username, PacketFormatter.format(pkt)))
try:
PacketReceiver.connectionMade(self)
self._handlers = dict()
self.register()
except:
log.msg("Error in protocol.connectionMade: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value,
exc_traceback)
log.msg("Lines: %s" % lines)
def cancelParticipation(self, usr):
try:
self.participatingPlayers.pop(self.participatingPlayers.index(usr))
log.msg('cancelParticipation: %s=%s' % (usr.profile.id, usr.profile.name))
except ValueError:
log.msg(
'WARN player (%s) is cancelling participation, '
'but was not among participants.' % (
usr.profile.name))
try:
if self.match is not None:
matchId = self.match.id
log.msg('cancelParticipation: matchId: %s' % matchId)
if matchId > -1:
self.lobby.matchData.MatchStatusSetCancel(matchId, usr.profile.id)
except:
log.msg("Error in cancelParticipation: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
return 0xff
def _reschedule(result):
log.msg('NOTICE: Ranks successfully computed for all profiles.')
try:
days = int(self.serverConfig.ComputeRanksInterval['days'])
except:
days = None
try:
seconds = int(
self.serverConfig.ComputeRanksInterval['seconds'])
except:
seconds = None
if days is None and seconds is None or \
days==0 and seconds==0:
# default to re-compute every day
days, seconds = 1, 0
elif days is None and seconds is not None:
days = 0
elif seconds is None and days is not None:
seconds = 0
td = timedelta(days=days, seconds=seconds)
log.msg('Rank-compute interval is: %s' % td)
log.msg('Scheduling next rank-compute for: %s' %
(datetime.now() + td))
seconds = td.days * 24 * 60 * 60 + td.seconds
reactor.callLater(seconds, self.computeRanks)
def _packetReceived(self, pkt):
self.resetTimeout()
try:
if self.factory.serverConfig.Debug:
try:
username = self._user.profile.name
except AttributeError:
username = ''
log.debug('[RECV {%s}]: %s' %
(username, PacketFormatter.format(pkt)))
# handle heartbeat packet here, since it's the same
# across all types of servers
if pkt.header.id == 0x0005:
pkt.header.packet_count = self._count
self.send(pkt)
return
# let subclasses handle it
self.packetReceived(pkt)
except:
log.msg("Error in protocol._packetReceived: %s" %
sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value,
exc_traceback)
log.msg("Lines: %s" % lines)
log.msg('[RECV {%s}]: %s' %
(username, PacketFormatter.format(pkt)))
def _packetReceived(self, pkt):
self.resetTimeout()
try:
if self.factory.serverConfig.Debug:
try:
username = self._user.profile.name
except AttributeError:
username = ''
log.debug('[RECV {%s}]: %s' % (
username, PacketFormatter.format(pkt)))
# handle heartbeat packet here, since it's the same
# across all types of servers
if pkt.header.id == 0x0005:
pkt.header.packet_count = self._count
self.send(pkt)
return
# let subclasses handle it
self.packetReceived(pkt)
except:
log.msg("Error in protocol._packetReceived: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
log.msg('[RECV {%s}]: %s' % (username, PacketFormatter.format(pkt)))
def createRoom_4310(self, pkt):
thisLobby = self.factory.getLobbies()[self._user.state.lobbyId]
roomName = util.stripZeros(pkt.data[0:64])
try:
existing = thisLobby.getRoom(roomName)
self.sendData(0x4311,'\xff\xff\xff\x10')
except KeyError:
room = lobby.Room(thisLobby)
room.name = roomName
room.usePassword = struct.unpack('!B',pkt.data[64:65])[0] == 1
if room.usePassword:
room.password = util.stripZeros(pkt.data[65:80])
# put room creator into the room
room.enter(self._user)
# add room to the lobby
thisLobby.addRoom(room)
log.msg('Room created: %s' % str(room))
# notify all users in the lobby about the new room
self.sendRoomUpdate(room)
# notify all users in the lobby that player is now in a room
self.sendPlayerUpdate(room.id)
self.sendZeros(0x4311,4)
def render_POST(self, request):
request.setHeader('Content-Type', 'text/xml')
try:
entry = request.args[b'entry'][0]
except KeyError:
entry = b''
entry = entry.decode('utf-8')
try:
try:
entryIndex = self.config.bannedList.Banned.index(entry)
except ValueError:
if entry.strip() != b'':
self.config.bannedList.Banned.append(entry)
self.config.bannedList.save()
self.config.makeFastBannedList()
return ('%s<actionAccepted href="/banned" />' %
XML_HEADER).encode('utf-8')
except Exception as info:
request.setResponseCode(500)
log.msg('SERVER ERROR: %s' % info)
return ('%s<error text="server error"/>' %
XML_HEADER).encode('utf-8')
def addToChatHistory(self, chatMessage):
self.chatHistory.append(chatMessage)
try:
if chatMessage.toProfile is not None:
log.msg('[CHAT] [%s] (%s -> %s) %s' % (self.name, chatMessage.fromProfile.name, chatMessage.toProfile.name, chatMessage.text.decode('utf-8')))
else:
log.msg('[CHAT] [%s] (%s) %s' % (self.name, chatMessage.fromProfile.name, chatMessage.text.decode('utf-8')))
except:
log.msg("Error in addToChatHistory: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
# keep only last MAX_MESSAGES messages. We don't want this
# to be a memory leak
del self.chatHistory[0:-MAX_MESSAGES]
def goalAway(self):
state = self.state
if state == MatchState.FIRST_HALF:
self.score_away_1st += 1
elif state == MatchState.SECOND_HALF:
self.score_away_2nd += 1
elif state == MatchState.ET_FIRST_HALF:
self.score_away_et1 += 1
elif state == MatchState.ET_SECOND_HALF:
self.score_away_et2 += 1
elif state == MatchState.PENALTIES:
self.score_away_pen += 1
else:
try:
log.msg("WARNING: Unknown game state: %s. Adding goal to first half." % state)
self.score_away_1st += 1
except:
log.msg("Error in goalHome: %s" % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
def _failed(error):
log.msg('ERROR: %s' % str(error.value))
request.setResponseCode(500)
request.write(self.sendResponse(
fmt, request, 'ERROR: Unable to register: server errror'))
request.finish()
def timeoutConnection(self):
log.msg("___init___.py: timeoutConnection")
def render_POST(self, request):
def _created(usr):
request.write(self.sendResponse(
fmt, request, 'SUCCESS: Registration complete'))
request.finish()
def _failed(error):
log.msg('ERROR: %s' % str(error.value))
request.setResponseCode(500)
request.write(self.sendResponse(
fmt, request, 'ERROR: Unable to register: server errror'))
request.finish()
def _modifyUser(results, serial, username, hash, nonce):
if not results:
request.setResponseCode(404)
request.write(
self.sendResponse(
fmt, request,
'ERROR: Cannot modify user: invalid nonce'))
request.finish()
return
d = self.config.createUser(username, serial, hash, nonce)
d.addCallback(_created)
d.addErrback(_failed)
return d
def _createNew(results, serial, username, hash):
if results:
request.setResponseCode(409)
request.write(
self.sendResponse(
fmt, request,
'ERROR: Cannot register: username taken'))
request.finish()
return
d = self.config.createUser(username, serial, hash, None)
d.addCallback(_created)
d.addErrback(_failed)
return d
serial = request.args['serial'][0]
username = request.args['user'][0]
hash = request.args['hash'][0]
nonce = request.args['nonce'][0]
try: fmt = request.args['format'][0]
except: fmt = None
#userKey = '%s-%s' % (
# binascii.b2a_hex(
# self.cipher.encrypt(util.padWithZeros(serial,24))),
# binascii.b2a_hex(
# self.cipher.encrypt(binascii.a2b_hex(hash))))
#print 'userKey: {%s}' % userKey
hash = binascii.b2a_hex(self.cipher.encrypt(binascii.a2b_hex(hash)))
log.msg('userHash: {%s}' % hash)
request.setHeader('Content-Type','text/xml')
if self.config.isBanned(request.getClientIP()):
request.setResponseCode(403)
return self.sendResponse(
fmt, request, 'ERROR: Cannot register: your IP is banned')
elif nonce in [None,'']:
# create new
d = self.config.userData.findByUsername(username)
d.addCallback(_createNew, serial, username, hash)
d.addErrback(_failed)
return server.NOT_DONE_YET
else:
# modify existing
d = self.config.userData.findByNonce(nonce)
d.addCallback(_modifyUser, serial, username, hash, nonce)
d.addErrback(_failed)
return server.NOT_DONE_YET
def exit(self, usr):
try:
log.debug('Room.exit: username=%s profiles=%s' % (usr.username, ','.join([x.name for x in usr.profiles])))
log.debug('Room.exit: usr.state.room.name=%s' % usr.state.room.name)
except:
log.msg('ERROR logging Room.exit')
usr.state.inRoom = 0
usr.state.noLobbyChat = 0
usr.state.room = None
try:
log.debug('self.owner.profile.name=%s' % self.owner.profile.name)
except:
log.msg('ERROR logging Room.exit (2)')
try:
try:
for usr2 in self.players:
log.debug('self.players.profiles=%s' % ','.join([x.name for x in usr2.profiles]))
except:
log.msg('Room.exit: Error iterating (1) %s' % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
index = self.getPlayerPosition(usr)
log.debug('popping index=%s' % index)
exiting = self.players.pop(index)
try:
for usr2 in self.players:
log.debug('self.players.profiles=%s' % ','.join([x.name for x in usr2.profiles]))
except:
log.msg('Room.exit: Error iterating (2) %s' % sys.exc_info()[0])
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
log.msg("Lines: %s" % lines)
except:
log.msg(
'WARN: player (%s) exiting, but was not in the room' % (
usr.profile.name))
else:
if self.isOwner(exiting):
log.debug('owner exiting')
# owner is exiting: assign new owner, if anybody
# is still left in the room.
if self.players:
self.setOwner(self.players[0])
