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 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 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 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_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")
