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