def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. datagramCleanup = PyDatagram() datagramCleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) # Activate the avatar on the DBSS: self.csm.air.sendActivate(self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': \ [self.account.get('ACCESS_LEVEL', 100)]}) # Next, add them to the avatar channel: datagram = PyDatagram() datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Eliminate race conditions. taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % (self.avId), extraArgs=[channel], appendTask=True)
def handleConnected(self): self.districtId = self.allocateChannel() # register the AI on the state server... dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_ADD_SHARD) dg.addUint32(self.districtId) dg.addString(self.districtName) dg.addUint32(self.districtPopulation) self.send(dg) # add a post remove to remove the shard from the state server # when we disconnect from the message director... dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_REMOVE_SHARD) self.addPostRemove(dg) self.rootObj = DistributedObjectAI(self) self.rootObj.generateWithRequiredAndId(self.districtId, 0, 0) self.notify.info('Creating managers...') self.createManagers() if self.config.GetBool('want-safe-zones', True): self.notify.info('Creating safe zones...') self.createSafeZones() if self.config.GetBool('want-cog-headquarters', True): self.notify.info('Creating Cog headquarters...') self.createCogHeadquarters() self.notify.info('Done.')
def attack(self, charid, targetid): myPyDatagram = PyDatagram() myPyDatagram.addUint8(ATTACK) myPyDatagram.addString(charid) myPyDatagram.addString(targetid) self.cWriter.send(myPyDatagram, self.myConnection)
def login(self, cookie, sig): self.notify.debug("Received login cookie %r from %d" % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString("Logins are currently disabled. Please try again later.") self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, "Client is already logged in.") return # Test the signature key = ( config.GetString("csmud-secret", "streetlamps") + config.GetString("server-version", "no_version_set") + FIXED_KEY ) computedSig = hmac.new(key, cookie, hashlib.sha256).digest() if sig != computedSig: self.killConnection(sender, "The accounts database rejected your cookie") return if sender in self.connection2fsm: self.killConnectionFSM(sender) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request("Start", cookie)
def authenticate(self): login = self.loginwindow.loginEntry.get() password = self.loginwindow.passwordEntry.get() self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.cReader.setTcpHeaderSize(4) self.cWriter.setTcpHeaderSize(4) self.myConnection = self.cManager.openTCPClientConnection(IP, PORT, 5000) if self.myConnection: self.cReader.addConnection(self.myConnection) print 'Client listening on', IP, ':', PORT taskMgr.add(self.tskReaderPolling, "Poll the connection reader") myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_MESSAGE) myPyDatagram.addString(login) myPyDatagram.addString(password) self.cWriter.send(myPyDatagram, self.myConnection) else: print 'Can\'t connect to server on', IP, ':', PORT
def enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader(self.csm.GetAccountConnectionChannel(int(self.databaseId)), self.csm.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(100) dg.addString('This account has been logged in elsewhere.') self.csm.air.send(dg) # Next, add this connection to the account channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.databaseId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.databaseId << 32) # accountId in high 32 bits, 0 in low (no avatar) self.csm.air.send(dg) # Un-sandbox them! dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) # ESTABLISHED state. BIG FAT SECURITY RISK!!! self.csm.air.send(dg) # We're done. self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def sendShardInfo(self): dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_UPDATE_SHARD) dg.addString(self.districtName) dg.addUint32(self.districtPopulation) self.send(dg)
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) datagramCleanup = PyDatagram() datagramCleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]}) datagram = PyDatagram() datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target << 32 | self.avId) self.csm.air.send(datagram) taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % self.avId, extraArgs=[channel], appendTask=True)
def __handleSetAvatar(self): channel = self.loginManager.GetAccountConnectionChannel(self.sender) cleanupDatagram = PyDatagram() cleanupDatagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) cleanupDatagram.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(cleanupDatagram.getMessage()) self.loginManager.air.send(datagram) self.loginManager.air.sendActivate(self.avId, 0, 0, self.loginManager.air.dclassesByName['DistributedToonUD']) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.loginManager.GetPuppetConnectionChannel(self.avId)) self.loginManager.air.send(datagram) self.loginManager.air.clientAddSessionObject(channel, self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.sender << 32 | self.avId) # accountId in high 32 bits, avatar in low. self.loginManager.air.send(datagram) self.loginManager.air.setOwner(self.avId, channel) self._handleDone()
def onCrossClicked(self): if self.phase == 'tile' and self.cux is not False and self.party['yourturn']: if self.subphase == 'free': # if we clicked on a character if self.party['map']['tiles'][self.cux][self.cuy][self.cuz].has_key('char'): charid = self.party['map']['tiles'][self.cux][self.cuy][self.cuz]['char'] myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_PASSIVE_WALKABLES) myPyDatagram.addString(charid) self.cWriter.send(myPyDatagram, self.myConnection) elif self.subphase == 'passivewalkables': self.clearZone() self.cancel_snd.play() self.subphase = 'free' elif self.subphase == 'move': self.clearZone() self.cancel_snd.play() self.subphase = None self.turn() elif self.subphase == 'attack': self.clearZone() self.cancel_snd.play() self.subphase = None self.turn()
def bootClient(self, reason, av): dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(av), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(106) dg.addString(reason) self.air.send(dg)
def killConnection(self, connId, reason): datagram = PyDatagram() datagram.addServerHeader(connId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(122) datagram.addString(reason) self.air.send(datagram)
def enterSetAccount(self): if self.accessLevel: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'ACCESS_LEVEL': self.accessLevel}) datagram = PyDatagram() datagram.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in from elsewhere.') self.csm.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(datagram) access = self.account.get('ACCESS_LEVEL', 0) if access >= 200: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) self.csm.air.send(dg) datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) self.csm.air.send(datagram) self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.userId) }) self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.time())]) self.demand('Off')
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. datagramCleanup = PyDatagram() datagramCleanup.addServerHeader( self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) # Activate the avatar on the DBSS: self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]}) # Next, add them to the avatar channel: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader( self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Tell TTRFriendsManager somebody is logging in: self.csm.air.friendsManager.toonOnline(self.avId, self.avatar) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off')
def killConnection(self, connectionId, reason): # Sends CLIENTAGENT_EJECT to the given connectionId with the given reason. datagram = PyDatagram() datagram.addServerHeader(connectionId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedReason["connectionKilled"]) datagram.addString(reason) self.air.send(datagram)
def killConnection(self, connId, code=122, reason=''): self.notify.info('Booting client: %d out for reason(%d): %s' % (int(connId), int(code), str(reason))) dg = PyDatagram() dg.addServerHeader(connId, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(int(code)) dg.addString(str(reason)) self.air.send(dg)
def killConnection(self, connId, reason): datagram = PyDatagram() datagram.addServerHeader( connId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(122) datagram.addString(reason) self.air.send(datagram)
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. dgcleanup = PyDatagram() dgcleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dgcleanup.addUint32(self.avId) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) # Get the avatar's "true" access. (without "server" bit) adminAccess = self.account.get('ADMIN_ACCESS', 0) adminAccess = adminAccess - adminAccess % 100 # Activate the avatar on the DBSS: self.csm.air.sendActivate(self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) # Next, add them to the avatar channel: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target<<32 | self.avId) # accountId in high 32 bits, avatar in low self.csm.air.send(dg) # Finally, grant ownership and shut down. dg = PyDatagram() dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(self.csm.GetAccountConnectionChannel(self.target)) # Set ownership channel to the connection's account channel. self.csm.air.send(dg) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) # Tell everything that an avatar is coming online! friendsList = [x for x, y in self.avatar['setFriendsList'][0]] self.csm.air.netMessenger.send('avatarOnline', [self.avId, friendsList]) # Post-remove for an avatar that disconnects unexpectedly. dgcleanup = self.csm.air.netMessenger.prepare('avatarOffline', [self.avId]) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) self.csm.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target) self.demand('Off')
def createParty(self, mapname): import time partyname = str(int(time.time())) myPyDatagram = PyDatagram() myPyDatagram.addUint8(CREATE_PARTY) myPyDatagram.addString(partyname) myPyDatagram.addString(mapname) self.cWriter.send(myPyDatagram, self.myConnection)
def killConnection(self, connectionId, reason, code=OTPGlobals.BootedConnectionKilled): datagram = PyDatagram() datagram.addServerHeader(connectionId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(code) datagram.addString(reason) self.air.send(datagram)
def enterSetAccount(self): # If somebody's already logged into this account, disconnect them. datagram = PyDatagram() datagram.addServerHeader( self.gameServicesManager.GetAccountConnectionChannel( self.accountId), self.gameServicesManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedReason["loggedInElsewhere"]) datagram.addString('This account has been logged into elsewhere.') self.gameServicesManager.air.send(datagram) # Now we'll add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.gameServicesManager.GetAccountConnectionChannel( self.accountId)) self.gameServicesManager.air.send(datagram) # Set their sender channel to represent their account affiliation. datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar). self.gameServicesManager.air.send(datagram) # We can now un-sandbox the sender. self.gameServicesManager.air.setClientState(self.target, 2) # ESTABLISHED state. # Update the last login timestamp. self.gameServicesManager.air.dbInterface.updateObject( self.gameServicesManager.air.dbId, self.accountId, self.gameServicesManager.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ACCESS_LEVEL': self.accessLevel }) # We're done. self.gameServicesManager.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, dbId=self.databaseId, playToken=self.playToken) # Send the acceptLogin update through the GameServicesManager & set this operation's state to Off. self.gameServicesManager.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def doUpdate(self, updateType, data): self.heartbeat() if updateType == "inv": return # rip crash dg = PyDatagram() dg.addUint8(0) dg.addString(updateType) dg.appendData(data) self.setShardData(dg.getMessage())
def moveCharacterTo(self, charid, dest): (x2, y2, z2) = dest myPyDatagram = PyDatagram() myPyDatagram.addUint8(MOVE_TO) myPyDatagram.addString(charid) myPyDatagram.addUint8(x2) myPyDatagram.addUint8(y2) myPyDatagram.addUint8(z2) self.cWriter.send(myPyDatagram, self.myConnection)
def path(self, charid, dest): orig = self.getCharacterCoords(charid) origdir = self.sprites[charid].realdir (x, y, z) = dest myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_PATH) myPyDatagram.addString(charid) myPyDatagram.addUint8(x) myPyDatagram.addUint8(y) myPyDatagram.addUint8(z) self.cWriter.send(myPyDatagram, self.myConnection)
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. dgcleanup = PyDatagram() dgcleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dgcleanup.addUint32(self.avId) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) # Activate the avatar on the DBSS: self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) # Next, add them to the avatar channel: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target << 32 | self.avId) # accountId in high 32 bits, avatar in low self.csm.air.send(dg) # Finally, grant ownership and shut down. dg = PyDatagram() dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(self.target << 32 | self.avId) # accountId in high 32 bits, avatar in low self.csm.air.send(dg) # Tell TTRFriendsManager somebody is logging in: self.csm.air.friendsManager.toonOnline(self.avId, self.avatar) # Tell the GlobalPartyManager as well self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off')
def enterSetAccount(self): # First, if there's anybody on the account, kill them for redundant login: datagram = PyDatagram() datagram.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in from elsewhere.') self.csm.air.send(datagram) # Next, add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) # Account ID in high 32 bits, 0 in low (no avatar): datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) # Un-sandbox them! datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) # ESTABLISHED self.csm.air.send(datagram) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'LAST_LOGIN': time.ctime(time.mktime(time.gmtime())), 'ACCOUNT_ID': str(self.userId)}) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.mktime(time.gmtime()))]) self.demand('Off')
def enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(100) dg.addString('This account has been logged in elsewhere.') self.csm.air.send(dg) # Next, add this connection to the account channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar) self.csm.air.send(dg) # Un-sandbox them! dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) # ESTABLISHED state. self.csm.air.send(dg) fields = { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId) } if self.adminAccess != -1: fields.update({'ADMIN_ACCESS': self.adminAccess}) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], fields) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.databaseId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.csm.account2username[self.target] = self.username self.demand('Off')
def enterSetAccount(self): dg = PyDatagram() dg.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(100) dg.addString('This account has been logged in elsewhere.') self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(dg) access = self.account.get('ADMIN_ACCESS', 0) if access >= 400: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 500: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) self.csm.air.send(dg) self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ADMIN_ACCESS': self.adminAccess }) self.csm.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, webAccId=self.databaseId, cookie=self.cookie) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def login(self, cookie, sessionKey): self.notify.debug('Received login cookie %r from %d' % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return if sender in self.connection2fsm: # Hot fix for potential toons that's FSM is stuck in state. self.connection2fsm[sender].demand('Off') # kick the client because there is a major issue! self.killConnection( sender, 'Failed to login, because your account is already in FSM state!' ) return if sessionKey != self.sessionKey: self.killConnection( sender, 'Failed to login, recieved a bad login cookie!') # notify the admin that someone tried to login with a custom client. self.notify.warning( '%s: Tried to login with a custom client using sessionKey, %s!' % (sender, str(sessionKey))) return if self.banManager.getToonBanned(cookie): self.killConnection(sender, self.banManager.getToonBanReason(cookie)) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def toonOnline(self, doId, friendsList): self.onlineToons.append(doId) channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate('goingOffline', self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, 'friendOnline', [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, 'friendOnline', [doId, 0, 0])
def __handleSetAccount(self): # if somebody's already logged into this account, disconnect them datagram = PyDatagram() datagram.addServerHeader( self.loginManager.GetAccountConnectionChannel(self.accountId), self.loginManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in elsewhere.') self.loginManager.air.send(datagram) # add connection to account channel datagram = PyDatagram() datagram.addServerHeader(self.sender, self.loginManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.loginManager.GetAccountConnectionChannel(self.accountId)) self.loginManager.air.send(datagram) # set sender channel to represent account affiliation datagram = PyDatagram() datagram.addServerHeader(self.sender, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.accountId << 32) # accountId is in high 32 bits, 0 in low (no avatar). self.loginManager.air.send(datagram) # set client state to established, thus un-sandboxing the sender self.loginManager.air.setClientState(self.sender, 2) responseData = { 'returnCode': 0, 'respString': '', 'accountNumber': self.sender, 'createFriendsWithChat': 'YES', 'chatCodeCreationRule': 'YES', 'access': 'FULL', 'WhiteListResponse': 'YES', 'lastLoggedInStr': self.getLastLoggedInStr(), 'accountDays': self.getAccountDays(), 'serverTime': int(time.time()), 'toonAccountType': 'NO_PARENT_ACCOUNT', 'userName': str(self.databaseId) } responseBlob = json.dumps(responseData) self.loginManager.sendUpdateToChannel(self.sender, 'loginResponse', [responseBlob]) self._handleDone()
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. datagramCleanup = PyDatagram() datagramCleanup.addServerHeader( self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) # Activate the avatar on the DBSS: self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)], 'setBankMoney': [self.account.get('MONEY', 0)]}) # Next, add them to the avatar channel: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Eliminate race conditions. taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % self.avId, extraArgs=[channel], appendTask=True)
def enterSetAccount(self): # First, if there's anybody on the account, kill them for redundant login: datagram = PyDatagram() datagram.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in from elsewhere.') self.csm.air.send(datagram) # Next, add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) # Account ID in high 32 bits, 0 in low (no avatar): datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) # Un-sandbox them! datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) # ESTABLISHED self.csm.air.send(datagram) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(time.mktime(time.gmtime())), 'ACCOUNT_ID': str(self.userId) }) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.mktime(time.gmtime()))]) self.demand('Off')
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) dgcleanup = PyDatagram() dgcleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dgcleanup.addUint32(self.avId) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) adminAccess = self.account.get('ADMIN_ACCESS', 0) adminAccess = adminAccess - adminAccess % 100 self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_SESSION_OBJECT) dg.addUint32(self.avId) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target << 32 | self.avId) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(self.csm.GetAccountConnectionChannel(self.target)) self.csm.air.send(dg) fields = self.avatar fields.update( {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) self.csm.air.friendsManager.toonOnline(self.avId, fields) self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target) self.demand('Off')
def enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader(self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(100) dg.addString('This account has been logged in elsewhere.') self.csm.air.send(dg) # Next, add this connection to the account channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar) self.csm.air.send(dg) # Un-sandbox them! dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) # ESTABLISHED state. self.csm.air.send(dg) fields = {'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId)} if self.adminAccess != -1: fields.update({'ADMIN_ACCESS': self.adminAccess}) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], fields) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.databaseId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.csm.account2username[self.target] = self.username self.demand('Off')
def login(self, cookie, sessionKey): sender = self.air.getMsgSender() #if not self.AccountFirewallUD.checkPlayerLogin(cookie): # self.killConnection(sender, 'Your account has been disallowed login to Project Altis. Please try again later.') # return self.notify.debug('Received login cookie %r from %d' % (cookie, sender)) if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return if sender in self.connection2fsm: # hot fix, remove the sender from the fsm and request the fsm state OFF self.connection2fsm[sender].demand('Off') if sessionKey != self.sessionKey: self.killConnection( sender, 'Failed to login, recieved a bad login cookie!') # notify the admin that someone tried to login with a custom client. self.notify.warning('%s: Tried to login with a custom client!' % (sender)) return if self.banManager.getToonBanned(cookie): self.killConnection(sender, self.banManager.getToonBanReason(cookie)) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def toonOnline(self, doId, fields): self.onlineToons.append(doId) self.toonAccess[doId] = fields.get("setAdminAccess", [0])[0] self.toonNames[doId] = fields["setName"][0] self.toonAccIds[doId] = fields.get("setDISLid", [0])[0] friendsList = fields["setFriendsList"][0] channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate("goingOffline", self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, "friendOnline", [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, "friendOnline", [doId, 0, 0])
def login(self, cookie, sig, secret): self.notify.debug('Received login cookie %r from %d' % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return # Test Server Secret serversecret = config.GetString('csmud-secret', 'streetlamps') if secret != serversecret: self.killConnection(sender, 'The accounts database rejcts you secret key') return # Test the signature key = config.GetString( 'csmud-secret', 'streetlamps') + config.GetString( 'server-version', 'no_version_set') + FIXED_KEY computedSig = hmac.new(key, cookie, hashlib.sha256).digest() if sig != computedSig: self.killConnection(sender, 'The accounts database rejected your cookie') return if sender in self.connection2fsm: self.killConnectionFSM(sender) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def toonOnline(self, doId, fields): self.onlineToons.append(doId) self.toonAccess[doId] = fields.get('setAdminAccess', [0])[0] self.toonNames[doId] = fields['setName'][0] self.toonAccIds[doId] = fields.get('setDISLid', [0])[0] friendsList = fields['setFriendsList'][0] channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate('goingOffline', self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, 'friendOnline', [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, 'friendOnline', [doId, 0, 0])
def enterSetAccount(self): datagram = PyDatagram() datagram.addServerHeader( self.gameServicesManager.GetAccountConnectionChannel( self.accountId), self.gameServicesManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedLoggedInElsewhere) datagram.addString('This account has been logged into elsewhere.') self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.gameServicesManager.GetAccountConnectionChannel( self.accountId)) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.accountId << 32) self.gameServicesManager.air.send(datagram) self.gameServicesManager.air.setClientState(self.target, 2) self.gameServicesManager.air.dbInterface.updateObject( self.gameServicesManager.air.dbId, self.accountId, self.gameServicesManager.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ACCESS_LEVEL': self.accessLevel }) self.gameServicesManager.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, dbId=self.databaseId, playToken=self.playToken) self.gameServicesManager.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. datagramCleanup = PyDatagram() datagramCleanup.addServerHeader( self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) # setup the avatar's inventory. self.csm.air.inventoryManager.initiateInventory(self.avId, self.inventorySetup)
def d_setShardData(self): dg = PyDatagram() self.context += 1 self.context %= 200 dg.addUint8(self.context) buildings = self.air.doFindAllInstances( DistributedBuildingAI.DistributedBuildingAI) for bldg in buildings: if bldg.__class__ in ( DistributedBuildingAI.DistributedBuildingAI, DistributedAnimBuildingAI.DistributedAnimBuildingAI): if not bldg.zoneId % 1000: # sz bldg, ignore continue if bldg.zoneId // 1000 == 7: # ff bldg, ignore now continue data = bldg.getPickleData() dg.addString("block") dg.addUint16(bldg.zoneId - (bldg.zoneId % 1000)) dg.addUint16(bldg.zoneId) dg.addUint8(int(data['block'])) dg.addString(data['state'].lower()) dg.addUint8(ord(data['track'])) dg.addUint8(int(data['difficulty'])) dg.addInt8(int(data['numFloors'])) self.bldgs.add(bldg) self.writeInvasion(dg) self.sendUpdate("setShardData", [dg.getMessage()]) self.air.notify.info("Sent shard data to UD") taskMgr.doMethodLater(60, self.__timeout, 'UD-sync-timeout')
def d_updateBlock(self, bldg): if not bldg in self.bldgs: return data = bldg.getPickleData() dg = PyDatagram() dg.addUint16(bldg.zoneId - (bldg.zoneId % 1000)) dg.addUint16(bldg.zoneId) dg.addUint8(int(data['block'])) state = data['state'].lower() if state.startswith('clear'): state = 'cogdo' if state.endswith('cogdo') else 'suit' dg.addString(state) dg.addUint8(ord(data['track'])) dg.addUint8(int(data['difficulty'])) dg.addInt8(int(data['numFloors'])) self.sendUpdate("doUpdate", ["block", dg.getMessage()])
def d_setShardData(self): dg = PyDatagram() self.context += 1 self.context %= 200 dg.addUint8(self.context) buildings = self.air.doFindAllInstances(DistributedBuildingAI.DistributedBuildingAI) for bldg in buildings: if bldg.__class__ in (DistributedBuildingAI.DistributedBuildingAI, DistributedAnimBuildingAI.DistributedAnimBuildingAI): if not bldg.zoneId % 1000: # sz bldg, ignore continue if bldg.zoneId // 1000 == 7: # ff bldg, ignore now continue data = bldg.getPickleData() dg.addString("block") dg.addUint16(bldg.zoneId - (bldg.zoneId % 1000)) dg.addUint16(bldg.zoneId) dg.addUint8(int(data['block'])) dg.addString(data['state'].lower()) dg.addUint8(ord(data['track'])) dg.addUint8(int(data['difficulty'])) dg.addInt8(int(data['numFloors'])) self.bldgs.add(bldg) self.writeInvasion(dg) self.sendUpdate("setShardData", [dg.getMessage()]) self.air.notify.info("Sent shard data to UD") taskMgr.doMethodLater(60, self.__timeout, 'UD-sync-timeout')
def setupAttackables(self, charid): myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_ATTACKABLES) myPyDatagram.addString(charid) self.cWriter.send(myPyDatagram, self.myConnection)
def processData(self, datagram): iterator = PyDatagramIterator(datagram) source = datagram.getConnection() msgID = iterator.getUint8() if msgID == LOGIN_MESSAGE: login = iterator.getString() password = iterator.getString() if login != password: myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_FAIL) myPyDatagram.addString('Wrong credentials.') self.cWriter.send(myPyDatagram, source) elif self.sessions.has_key(source): myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_FAIL) myPyDatagram.addString('Already logged in.') self.cWriter.send(myPyDatagram, source) elif login in self.players.keys(): myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_FAIL) myPyDatagram.addString('Username already in use.') self.cWriter.send(myPyDatagram, source) else: self.players[login] = source self.sessions[source] = {} self.sessions[source]['login'] = login print login, 'logged in.' myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_SUCCESS) self.cWriter.send(myPyDatagram, source) elif msgID == CREATE_PARTY: name = iterator.getString() mapname = iterator.getString() party = { 'name': name, 'mapname': mapname, 'map' : Map.load(mapname), 'chars': {}, 'log': {}, 'creator': self.sessions[source]['login'], 'players': [], } party['players'].append(self.sessions[source]['login']) self.parties[name] = party self.sessions[source]['party'] = name self.sessions[source]['player'] = len(party['players'])-1 self.updateAllPartyLists() print self.sessions[source]['login'], "created the party", name, "using the map", mapname myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_CREATED) myPyDatagram.addString32(json.dumps(party)) self.cWriter.send(myPyDatagram, source) elif msgID == GET_MAPS: self.playersinlobby.remove(source) mapnames = map( lambda m: m.split('.')[0], os.listdir(GAME+'/maps')) maps = [] for mapname in mapnames: mp = Map.load(mapname) del mp['tiles'] maps.append(mp) myPyDatagram = PyDatagram() myPyDatagram.addUint8(MAP_LIST) myPyDatagram.addString(json.dumps(maps)) self.cWriter.send(myPyDatagram, source) elif msgID == GET_PARTIES: self.playersinlobby.append(source) parties = deepcopy(self.parties) for party in parties.values(): del party['map']['tiles'] myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_LIST) myPyDatagram.addString32(json.dumps(parties)) self.cWriter.send(myPyDatagram, source) elif msgID == JOIN_PARTY: name = iterator.getString() party = self.parties[name] if len(party['players']) >= len(party['map']['chartiles']): parties = deepcopy(self.parties) for party in parties.values(): del party['map']['tiles'] myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_JOIN_FAIL) myPyDatagram.addString('Party '+name+' is full.') myPyDatagram.addString32(json.dumps(parties)) self.cWriter.send(myPyDatagram, source) else: party['players'].append(self.sessions[source]['login']) self.sessions[source]['party'] = name self.sessions[source]['player'] = len(party['players'])-1 self.playersinlobby.remove(source) print self.sessions[source]['login'], "joined the party", name myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_JOINED) myPyDatagram.addString32(json.dumps(party)) self.cWriter.send(myPyDatagram, source) for teamid,team in enumerate(party['map']['chartiles']): for chartile in team: x = int(chartile['x']) y = int(chartile['y']) z = int(chartile['z']) direction = int(chartile['direction']) charid = str(x)+str(y)+str(z) party['map']['tiles'][x][y][z]['char'] = charid party['chars'][charid] = Character.Random(charid, teamid, direction) if len(party['players']) == len(party['map']['chartiles']): for player in party['players']: myPyDatagram = PyDatagram() myPyDatagram.addUint8(START_BATTLE) myPyDatagram.addString32(json.dumps(party)) self.cWriter.send(myPyDatagram, self.players[player]) self.updateAllPartyLists() elif msgID == UPDATE_PARTY: party = self.parties[self.sessions[source]['party']] chars = party['chars'] aliveteams = {} for charid in chars.keys(): if chars[charid]['hp'] > 0: if aliveteams.has_key(chars[charid]['team']): aliveteams[chars[charid]['team']] = aliveteams[chars[charid]['team']] + 1 else: aliveteams[chars[charid]['team']] = 1 if len(aliveteams) < 2: for client in party['players']: if source == self.players[client]: myPyDatagram = PyDatagram() myPyDatagram.addUint8(BATTLE_COMPLETE) self.cWriter.send(myPyDatagram, self.players[client]) else: myPyDatagram = PyDatagram() myPyDatagram.addUint8(GAME_OVER) self.cWriter.send(myPyDatagram, self.players[client]) del self.parties[self.sessions[source]['party']] self.updateAllPartyLists() return for charid in chars.keys(): party['yourturn'] = int(chars[charid]['team']) == int(self.sessions[source]['player']) if chars[charid]['active']: myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_UPDATED) myPyDatagram.addBool(party['yourturn']) myPyDatagram.addString32(json.dumps(chars)) self.cWriter.send(myPyDatagram, source) return while True: for charid in chars.keys(): char = chars[charid] char['ct'] = char['ct'] + char['speed'] if char['ct'] >= 100: if char['hp'] > 0: char['active'] = True char['canmove'] = True char['canact'] = True party['yourturn'] = int(chars[charid]['team']) == int(self.sessions[source]['player']) myPyDatagram = PyDatagram() myPyDatagram.addUint8(PARTY_UPDATED) myPyDatagram.addBool(party['yourturn']) myPyDatagram.addString32(json.dumps(chars)) self.cWriter.send(myPyDatagram, source) return else: char['ct'] = 0 elif msgID == GET_WALKABLES: charid = iterator.getString() party = self.parties[self.sessions[source]['party']] walkables = Move.GetWalkables( party, charid ) myPyDatagram = PyDatagram() myPyDatagram.addUint8(WALKABLES_LIST) myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(walkables)) self.cWriter.send(myPyDatagram, source) elif msgID == GET_PASSIVE_WALKABLES: charid = iterator.getString() party = self.parties[self.sessions[source]['party']] walkables = Move.GetWalkables( party, charid ) myPyDatagram = PyDatagram() myPyDatagram.addUint8(PASSIVE_WALKABLES_LIST) myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(walkables)) self.cWriter.send(myPyDatagram, source) elif msgID == GET_PATH: charid = iterator.getString() x2 = iterator.getUint8() y2 = iterator.getUint8() z2 = iterator.getUint8() party = self.parties[self.sessions[source]['party']] orig = Character.Coords( party, charid ) x1 = orig[0] y1 = orig[1] z1 = orig[2] path = Move.GetPath( party, charid, x1, y1, z1, x2, y2, z2 ) myPyDatagram = PyDatagram() myPyDatagram.addUint8(PATH) myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(orig)) myPyDatagram.addUint8(party['chars'][charid]['direction']) myPyDatagram.addString(json.dumps((x2,y2,z2))) myPyDatagram.addString(json.dumps(path)) self.cWriter.send(myPyDatagram, source) elif msgID == MOVE_TO: charid = iterator.getString() x2 = iterator.getUint8() y2 = iterator.getUint8() z2 = iterator.getUint8() party = self.parties[self.sessions[source]['party']] orig = Character.Coords( party, charid ) x1 = orig[0] y1 = orig[1] z1 = orig[2] path = Move.GetPath( party, charid, x1, y1, z1, x2, y2, z2 ) walkables = Move.GetWalkables( party, charid ) del party['map']['tiles'][x1][y1][z1]['char'] party['map']['tiles'][x2][y2][z2]['char'] = charid party['chars'][charid]['direction'] = Move.GetNewDirection( x1, y1, x2, y2 ) party['chars'][charid]['canmove'] = False myPyDatagram = PyDatagram() myPyDatagram.addUint8(MOVED) myPyDatagram.addString(charid) myPyDatagram.addUint8(x2) myPyDatagram.addUint8(y2) myPyDatagram.addUint8(z2) self.cWriter.send(myPyDatagram, source) for playerid,playerlogin in enumerate(party['players']): if playerid != self.sessions[source]['player']: myPyDatagram = PyDatagram() myPyDatagram.addUint8(MOVED_PASSIVE) myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(walkables)) myPyDatagram.addString(json.dumps(path)) self.cWriter.send(myPyDatagram, self.players[playerlogin]) elif msgID == WAIT: charid = iterator.getString() direction = iterator.getUint8() party = self.parties[self.sessions[source]['party']] char = party['chars'][charid] if char['canmove'] and char['canact']: char['ct'] = char['ct'] - 60 elif char['canmove'] or char['canact']: char['ct'] = char['ct'] - 80 else: char['ct'] = char['ct'] - 100 char['direction'] = direction char['active'] = False char['canmove'] = False char['canact'] = False myPyDatagram = PyDatagram() myPyDatagram.addUint8(WAIT_SUCCESS) self.cWriter.send(myPyDatagram, source) for playerid,playerlogin in enumerate(party['players']): if playerid != self.sessions[source]['player']: myPyDatagram = PyDatagram() myPyDatagram.addUint8(WAIT_PASSIVE) myPyDatagram.addString(charid) myPyDatagram.addUint8(direction) self.cWriter.send(myPyDatagram, self.players[playerlogin]) elif msgID == GET_ATTACKABLES: charid = iterator.getString() party = self.parties[self.sessions[source]['party']] attackables = Attack.GetAttackables( party, charid ) myPyDatagram = PyDatagram() myPyDatagram.addUint8(ATTACKABLES_LIST) myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(attackables)) self.cWriter.send(myPyDatagram, source) elif msgID == ATTACK: charid1 = iterator.getString() charid2 = iterator.getString() party = self.parties[self.sessions[source]['party']] char1 = party['chars'][charid1] char2 = party['chars'][charid2] damages = char1['pa'] * char1['br'] / 100 * char1['pa'] char2['hp'] = char2['hp'] - damages*4 if char2['hp'] < 0: char2['hp'] = 0 char1['canact'] = False myPyDatagram = PyDatagram() myPyDatagram.addUint8(ATTACK_SUCCESS) myPyDatagram.addString(charid1) myPyDatagram.addString(charid2) myPyDatagram.addUint8(damages) self.cWriter.send(myPyDatagram, source) attackables = Attack.GetAttackables( party, charid1 ) for playerid,playerlogin in enumerate(party['players']): if playerid != self.sessions[source]['player']: myPyDatagram = PyDatagram() myPyDatagram.addUint8(ATTACK_PASSIVE) myPyDatagram.addString(charid1) myPyDatagram.addString(charid2) myPyDatagram.addUint8(damages) myPyDatagram.addString(json.dumps(attackables)) self.cWriter.send(myPyDatagram, self.players[playerlogin])
def enterSetAccount(self): # If necessary, update their account information: if self.accessLevel: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'ACCESS_LEVEL': self.accessLevel}) # If there's anybody on the account, kill them for redundant login: datagram = PyDatagram() datagram.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in from elsewhere.') self.csm.air.send(datagram) # Next, add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(datagram) # Subscribe to any "staff" channels that the account has access to. access = self.account.get('ADMIN_ACCESS', 0) if access >= 200: # Subscribe to the moderator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: # Subscribe to the administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: # Subscribe to the system administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) # Account ID in high 32 bits, 0 in low (no avatar): datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) # Un-sandbox them! datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) # ESTABLISHED self.csm.air.send(datagram) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'LAST_LOGIN': time.ctime(), 'LAST_LOGIN_TS': time.time(), 'ACCOUNT_ID': str(self.userId)}) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.time())]) self.demand('Off')
def directionChosen(self, charid, direction): myPyDatagram = PyDatagram() myPyDatagram.addUint8(WAIT) myPyDatagram.addString(charid) myPyDatagram.addUint8(direction) self.cWriter.send(myPyDatagram, self.myConnection)
def joinParty(self, name): myPyDatagram = PyDatagram() myPyDatagram.addUint8(JOIN_PARTY) myPyDatagram.addString(name) self.cWriter.send(myPyDatagram, self.myConnection)
def onMoveClicked(self, charid): myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_WALKABLES) myPyDatagram.addString(charid) self.cWriter.send(myPyDatagram, self.myConnection)
def enterSetAvatar(self): channel = self.gameServicesManager.GetAccountConnectionChannel( self.target) cleanupDatagram = PyDatagram() cleanupDatagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) cleanupDatagram.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(cleanupDatagram.getMessage()) self.gameServicesManager.air.send(datagram) creationDate = self.getCreationDate() accountDays = -1 if creationDate: now = datetime.fromtimestamp( time.mktime(time.strptime(time.ctime()))) accountDays = abs((now - creationDate).days) if accountDays < 0 or accountDays > 4294967295L: accountDays = 100000 self.gameServicesManager.sendUpdateToAccountId(self.target, 'receiveAccountDays', [accountDays]) accessLevel = self.account.get('ACCESS_LEVEL', 'NO_ACCESS') accessLevel = OTPGlobals.AccessLevelName2Int.get(accessLevel, 0) self.gameServicesManager.air.sendActivate( self.avId, 0, 0, self.gameServicesManager.air.dclassesByName[ self.gameServicesManager.avatarDclass], {'setAccessLevel': [accessLevel]}) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.gameServicesManager.GetPuppetConnectionChannel(self.avId)) self.gameServicesManager.air.send(datagram) self.gameServicesManager.air.clientAddSessionObject(channel, self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target << 32 | self.avId) self.gameServicesManager.air.send(datagram) self.gameServicesManager.air.setOwner(self.avId, channel) friendsList = [x for x, y in self.avatar['setFriendsList'][0]] self.gameServicesManager.air.ttoffFriendsManager.comingOnline( self.avId, friendsList) if self.gameServicesManager.air.ttoffFriendsManager: friendsManagerDclass = self.gameServicesManager.air.ttoffFriendsManager.dclass cleanupDatagram = friendsManagerDclass.aiFormatUpdate( 'goingOffline', self.gameServicesManager.air.ttoffFriendsManager.doId, self.gameServicesManager.air.ttoffFriendsManager.doId, self.gameServicesManager.air.ourChannel, [self.avId]) else: friendsManagerDoId = OtpDoGlobals.OTP_DO_ID_TTOFF_FRIENDS_MANAGER friendsManagerDclass = self.gameServicesManager.air.dclassesByName[ 'TTOffFriendsManagerUD'] cleanupDatagram = friendsManagerDclass.aiFormatUpdate( 'goingOffline', friendsManagerDoId, friendsManagerDoId, self.gameServicesManager.air.ourChannel, [self.avId]) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(cleanupDatagram.getMessage()) self.gameServicesManager.air.send(datagram) simbase.air.banManager.addClient(self.target, self.hwId) self.gameServicesManager.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target) self.demand('Off')
def enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT ) dg.addUint16(100) dg.addString("This account has been logged in elsewhere.") self.csm.air.send(dg) # Next, add this connection to the account channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(dg) # Subscribe to any "staff" channels that the account has access to. access = self.account.get("ADMIN_ACCESS", 0) if access >= 200: # Subscribe to the moderator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: # Subscribe to the administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: # Subscribe to the system administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar) self.csm.air.send(dg) # Un-sandbox them! dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) # ESTABLISHED state. BIG FAT SECURITY RISK!!! self.csm.air.send(dg) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName["AccountUD"], { "LAST_LOGIN": time.ctime(), "ACCOUNT_ID": self.databaseId, "ADMIN_ACCESS": self.adminAccess, "BETA_KEY_QUEST": self.betaKeyQuest, }, ) # Add a POST_REMOVE to the connection channel to execute the NetMessenger # message when the account connection goes RIP on the Client Agent. dgcleanup = self.csm.air.netMessenger.prepare("accountDisconnected", [self.accountId]) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) # We're done. self.csm.air.writeServerEvent( "account-login", clientId=self.target, accId=self.accountId, webAccId=self.databaseId, cookie=self.cookie ) self.csm.sendUpdateToChannel(self.target, "acceptLogin", []) self.demand("Off")