async def __handle_xml_data(self, data):
self.logger.debug('Received XML data: %s', data)
element_tree = Et.fromstring(data)
if element_tree.tag == 'policy-file-request':
await self.send_policy_file()
elif element_tree.tag == 'msg':
self.logger.debug('Received valid XML data')
try:
body_tag = element_tree[0]
action = body_tag.get('action')
packet = XMLPacket(action)
if packet in self.server.xml_listeners:
xml_listeners = self.server.xml_listeners[packet]
for listener in xml_listeners:
if listener.client_type is None or listener.client_type == self.client_type:
await listener(self, body_tag)
self.received_packets.add(packet)
else:
self.logger.warn('Packet did not contain a valid action attribute!')
except IndexError:
self.logger.warn('Received invalid XML data (didn\'t contain a body tag)')
else:
self.logger.warn('Received invalid XML data!')
@handlers.boot
async def igloos_load(server):
server.igloos = await IglooCollection.get_collection()
server.furniture = await FurnitureCollection.get_collection()
server.locations = await LocationCollection.get_collection()
server.flooring = await FlooringCollection.get_collection()
server.logger.info(f'Loaded {len(server.igloos)} igloos')
server.logger.info(f'Loaded {len(server.furniture)} furniture items')
server.logger.info(f'Loaded {len(server.locations)} igloo locations')
server.logger.info(f'Loaded {len(server.flooring)} igloo flooring')
@handlers.handler(XMLPacket('login'), priority=Priority.Low)
@handlers.allow_once
async def load_igloo_inventory(p):
p.igloos = await PenguinIglooCollection.get_collection(p.id)
p.igloo_rooms = await PenguinIglooRoomCollection.get_collection(p.id)
p.furniture = await PenguinFurnitureCollection.get_collection(p.id)
p.flooring = await PenguinFlooringCollection.get_collection(p.id)
p.locations = await PenguinLocationCollection.get_collection(p.id)
default_igloos = p.server.igloos.legacy_inventory if p.is_legacy_client else \
p.server.igloos.vanilla_inventory
for default_item in default_igloos:
if default_item.id not in p.igloos:
await p.igloos.insert(igloo_id=default_item.id)
default_locations = p.server.locations.legacy_inventory if p.is_legacy_client else \
active_ban = await Ban.query.where((Ban.penguin_id == data.id) & (
Ban.expires >= datetime.now())).gino.scalar()
if active_ban is not None:
return await p.close()
if data.id in p.server.penguins_by_id:
await p.server.penguins_by_id[data.id].close()
p.logger.info(f'{data.username} logged in successfully')
p.data = data
await p.send_xt('l')
@handlers.handler(XMLPacket('login'), client=ClientType.Vanilla)
@handlers.allow_once
@handlers.depends_on_packet(XMLPacket('verChk'), XMLPacket('rndK'))
async def handle_login(p, credentials: WorldCredentials):
tr = p.server.redis.multi_exec()
tr.get(f'{credentials.username}.lkey')
tr.get(f'{credentials.username}.ckey')
tr.delete(f'{credentials.username}.lkey', f'{credentials.username}.ckey')
login_key, confirmation_hash, _ = await tr.execute()
if login_key is None or confirmation_hash is None:
return await p.close()
login_key = login_key.decode()
login_hash = Crypto.encrypt_password(
login_key + config.client['AuthStaticKey']) + login_key
import config
from houdini import handlers
from houdini.handlers import XMLPacket
from houdini.converters import VersionChkConverter
from houdini.constants import ClientType
from houdini.data.buddy import BuddyList
@handlers.handler(XMLPacket('verChk'))
@handlers.allow_once
async def handle_version_check(p, version: VersionChkConverter):
if config.client['MultiClientSupport']:
if config.client['LegacyVersionChk'] == version:
p.client_type = ClientType.Legacy
elif config.client['VanillaVersionChk'] == version:
p.client_type = ClientType.Vanilla
elif config.client['DefaultVersionChk'] == version:
p.client_type = config.client['DefaultClientType']
if p.client_type is None:
await p.send_xml({'body': {'action': 'apiKO', 'r': '0'}})
await p.close()
else:
await p.send_xml({'body': {'action': 'apiOK', 'r': '0'}})
@handlers.handler(XMLPacket('rndK'))
@handlers.allow_once
async def handle_random_key(p, data):
from houdini.handlers import XMLPacket
from houdini.handlers.login import get_server_presence
from houdini.converters import Credentials
from houdini.data.penguin import Penguin
from houdini.data.moderator import Ban
from houdini.crypto import Crypto
from houdini.constants import ClientType
import asyncio
import bcrypt
import os
from datetime import datetime, timedelta
@handlers.handler(XMLPacket('login'))
@handlers.allow_once
@handlers.depends_on_packet(XMLPacket('verChk'), XMLPacket('rndK'))
async def handle_login(p, credentials: Credentials):
loop = asyncio.get_event_loop()
username, password = credentials.username, credentials.password
p.logger.info('{} is logging in!'.format(username))
data = await Penguin.query.where(Penguin.username == username).gino.first()
if data is None:
p.logger.info(
'{} failed to login: penguin does not exist'.format(username))
return await p.send_error_and_disconnect(100)