def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.object_class = bit_stream.read_int()
self.object_type = bit_stream.read_int()
self.server = bit_stream.read_int()
self.object_number = bit_stream.read_long()
def test_read_size(self):
cases = [
{
'data': b'\x00',
'expected': 4
}, # 0000
{
'data': b'\x80',
'expected': 8
}, # 1000
{
'data': b'\xC0',
'expected': 16
}, # 1100
{
'data': b'\xE0',
'expected': 32
}
] # 1110
for case in cases:
bit_stream = BitStream(case['data'])
result = bit_stream.__read_size__()
self.assertEqual(result, case['expected'])
with self.assertRaises(ValueError):
bit_stream = BitStream(b'\xF0') # 1111
result = bit_stream.__read_size__()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.x = bit_stream.read_int()
self.y = bit_stream.read_int()
self.z = bit_stream.read_int()
self.t = bit_stream.read_int()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
self.is_host = bit_stream.read_bool()
self.is_status_pending = bit_stream.read_bool()
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
self.aw_object_id.serialize(bit_stream)
self.player_avatar_id.serialize(bit_stream)
self.stats_type_id.serialize(bit_stream)
bit_stream.write_int(self.level)
self.object_id.serialize(bit_stream)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.uid = ObjectID()
self.uid.deserialize(bit_stream)
self.token = bit_stream.read_str()
self.max_vis_size = bit_stream.read_int()
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
bit_stream.write_none() # GSFZoneInstance
bit_stream.write_none() # GSFVillage
self.home.serialize(bit_stream)
bit_stream.write_str(self.sync_server_token)
bit_stream.write_str(self.sync_server_ip)
bit_stream.write_int(self.sync_server_port)
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
bit_stream.write_int(self.cx)
bit_stream.write_int(self.cy)
bit_stream.write_int(self.cz)
bit_stream.write_int(self.box)
bit_stream.write_int(self.boy)
bit_stream.write_int(self.boz)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.cx = bit_stream.read_int()
self.cy = bit_stream.read_int()
self.cz = bit_stream.read_int()
self.box = bit_stream.read_int()
self.boy = bit_stream.read_int()
self.boz = bit_stream.read_int()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.limit = bit_stream.read_int()
self.offset = bit_stream.read_int()
self.action = bit_stream.read_int()
self.hierarchies = []
for _ in range(bit_stream.read_int()):
self.hierarchies.append(bit_stream.read_str())
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
self.aw_object_id.serialize(bit_stream)
self.invite_player_id.serialize(bit_stream)
self.player_id.serialize(bit_stream)
bit_stream.write_bool(self.is_player_home)
bit_stream.write_int(self.invite_status)
bit_stream.write_dt(self.invite_date)
bit_stream.write_dt(self.blocked_date)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.quest_type_id = ObjectID()
self.quest_type_id.deserialize(bit_stream)
self.hierarchies = []
for _ in range(bit_stream.read_int()):
self.hierarchies.append(bit_stream.read_str())
self.return_locked = bit_stream.read_bool()
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
bit_stream.write_bool(self.sw)
bit_stream.write_bool(self.sx)
bit_stream.write_bool(self.sy)
bit_stream.write_bool(self.sz)
bit_stream.write_short(self.cx)
bit_stream.write_short(self.cy)
bit_stream.write_short(self.cz)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.sw = bit_stream.read_bool()
self.sx = bit_stream.read_bool()
self.sy = bit_stream.read_bool()
self.sz = bit_stream.read_bool()
self.cx = bit_stream.read_short()
self.cy = bit_stream.read_short()
self.cz = bit_stream.read_short()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.start = bit_stream.read_int()
self.max = bit_stream.read_int()
self.filter_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.filter_ids.append(item)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.player_ids.append(item)
self.is_invite_or_accept = bit_stream.read_bool()
self.is_host = bit_stream.read_bool()
self.permanent = bit_stream.read_bool()
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
self.aw_object_id.serialize(bit_stream)
bit_stream.write_int(len(self.asset_map))
for key in self.asset_map:
bit_stream.write_str(key)
bit_stream.write_int(len(self.asset_map[key]))
for item in self.asset_map[key]:
item.serialize(bit_stream)
bit_stream.write_int(len(self.asset_packages))
for item in self.asset_packages:
item.serialize(bit_stream)
def serialize(self, bit_stream: BitStream):
bit_stream.write_start()
bit_stream.write_int(self.min_experience)
bit_stream.write_int(self.max_experience)
bit_stream.write_int(self.min_time_played)
bit_stream.write_int(self.max_time_played)
bit_stream.write_none() # GSFPlayerExperienceLevel
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.container_id = ObjectID()
self.container_id.deserialize(bit_stream)
self.item_category_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.item_category_ids.append(item)
self.player_item_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.player_item_ids.append(item)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_avatar_id = ObjectID()
self.player_avatar_id.deserialize(bit_stream)
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
def test_write_int(self):
cases = [ # is_integer size data i s data
{
'expected': b'\x80',
'int': 0
}, # 1 0 0000
{
'expected': b'\x90',
'int': 4
}, # 1 0 0100
{
'expected': b'\x9C',
'int': 7
}, # 1 0 0111
{
'expected': b'\xC1\x00',
'int': 8
}, # 1 10 0000 1000
{
'expected': b'\xC8\x00',
'int': 64
}, # 1 10 0100 0000
{
'expected': b'\xCF\xE0',
'int': 127
}, # 1 10 0111 1111
{
'expected': b'\xE0\x08\x00',
'int': 128
}, # 1 110 0000 0000 1000
{
'expected': b'\xB0',
'int': -4
}, # 1 0 1100
{
'expected': b'\xA0',
'int': -8
}, # 1 0 1000
{
'expected': b'\xDE\xE0',
'int': -9
}, # 1 10 1111 0111
{
'expected': b'\xD8\x00',
'int': -64
}, # 1 10 1100 0000
{
'expected': b'\xD0\x00',
'int': -128
}, # 1 10 1000 0000
{
'expected': b'\xEF\xF7\xF0',
'int': -129
}
] # 1 110 1111 1111 0111 1111
for case in cases:
bit_stream = BitStream()
bit_stream.write_int(case['int'])
self.assertEqual(bit_stream.data, case['expected'])
async def process_message(self, peer_name: str,
data: bytearray) -> BitStream:
request_bs = BitStream(data)
message_header = MessageHeader()
message_header.deserialize(request_bs)
message = self.message_factory.build_message(message_header)
if not message:
log(
LogLevel.WARN,
'{} [bold yellow]<{}>[/] is not supported yet: {}'.format(
peer_name, message_header.message_type,
bytes(request_bs.data)))
return
if message_header.is_response:
log(
LogLevel.WARN,
'{} [bold yellow]<{}>[/] responses from client are not supported yet: {}'
.format(peer_name, message_header.message_type,
bytes(request_bs.data)))
return
message.request.deserialize(request_bs)
await message.process(message_header)
message_header.is_response = True
log(
LogLevel.INFO,
'{} Processed [bold blue]<{}>[/] with [bold blue]<{}> <{}>[/]'.
format(peer_name, message_header.message_type,
message_header.result_code, message_header.app_code))
response_bs = BitStream()
message_header.serialize(response_bs)
message.response.serialize(response_bs)
log(
LogLevel.DEBUG, '=>', {
'request_bs': bytes(request_bs.data),
'response_bs': bytes(response_bs.data),
'request': message.request.to_dict(),
'response': message.response.to_dict()
})
return response_bs
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.unity_version = bit_stream.read_str()
self.user_agent = bit_stream.read_str()
self.screen_resolution = bit_stream.read_str()
self.machine_os = bit_stream.read_str()
self.user_time = bit_stream.read_dt()
self.utc_offset_in_minutes = bit_stream.read_int()
self.ip_address = bit_stream.read_str()
def deserialize(self, bit_stream: BitStream):
bit_stream.read_start() # GSFMessage
bit_stream.read_start() # MessageHeader
self.__flags__ = bit_stream.read_int()
self.__service_class__ = bit_stream.read_int()
self.__message_type__ = bit_stream.read_int()
if self.is_service:
self.request_id = bit_stream.read_int()
if self.is_request:
bit_stream.read_str() # log_correlator (always empty)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.loc_id = ObjectID()
self.loc_id.deserialize(bit_stream)
self.building_id = ObjectID()
self.building_id.deserialize(bit_stream)
self.pos = Position()
self.pos.deserialize(bit_stream)
self.orientation = Orientation()
self.orientation.deserialize(bit_stream)
async def process_message(self, peer_name: str, data: bytearray) -> BitStream:
request_bs = BitStream(data)
message_header = MessageHeader()
message_header.deserialize(request_bs)
message = self.message_factory.build_message(message_header)
if message:
message.request.deserialize(request_bs)
log(f'{peer_name} Request <{message_header}> {message.request}', LogLevel.TRACE)
await message.process(message_header)
if message.response:
message_header.is_response = True
log(f'{peer_name} Response <{message_header}> {message.response}', LogLevel.TRACE)
response_bs = BitStream()
message_header.serialize(response_bs)
message.response.serialize(response_bs)
return response_bs
else:
log(f'{peer_name} No Response <{message_header.message_type}>', LogLevel.TRACE)
else:
log(f'{peer_name} Request <{message_header.message_type}> is not supported yet: {bytes(request_bs.data)}',
LogLevel.WARN)
def test_write_size(self):
cases = [
{'int': 0, 'expected': b'\x00'}, # 4
{'int': 4, 'expected': b'\x00'}, # 4
{'int': 7, 'expected': b'\x00'}, # 4
{'int': 8, 'expected': b'\x80'}, # 8
{'int': 64, 'expected': b'\x80'}, # 8
{'int': 127, 'expected': b'\x80'}, # 8
{'int': 128, 'expected': b'\xC0'}, # 16
{'int': -4, 'expected': b'\x00'}, # 4
{'int': -8, 'expected': b'\x00'}, # 4
{'int': -9, 'expected': b'\x80'}, # 8
{'int': -64, 'expected': b'\x80'}, # 8
{'int': -128, 'expected': b'\x80'}, # 8
{'int': -129, 'expected': b'\xC0'}] # 16
for case in cases:
bit_stream = BitStream()
bit_stream.__write_size__(case['int'], 4 * 8)
self.assertEqual(bit_stream.data, case['expected'], case['int'])
with self.assertRaises(ValueError):
BitStream().__write_size__(4294967296, 4 * 8)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.login_id = bit_stream.read_str()
self.password = bit_stream.read_str()
self.site_pin = bit_stream.read_int()
self.language_local_pair_id = ObjectID()
self.language_local_pair_id.deserialize(bit_stream)
self.user_queueing_token = bit_stream.read_str()
self.client_environment = ClientEnvironment()
self.client_environment.deserialize(bit_stream)
self.token = bit_stream.read_str()
self.login_type = bit_stream.read_int()
self.cnl = bit_stream.read_str()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.type_value = bit_stream.read_int()
self.lang_locale_pair_id = ObjectID()
self.lang_locale_pair_id.deserialize(bit_stream)
self.tier_id = ObjectID()
self.tier_id.deserialize(bit_stream)
self.birth_date = bit_stream.read_dt()
self.registration_date = bit_stream.read_dt()
self.preview_date = bit_stream.read_dt()
self.is_preview_enabled = bit_stream.read_bool()
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
self.secret_code = bit_stream.read_str()
self.name = bit_stream.read_str()
self.bio = bit_stream.read_str()
self.avatar_id = ObjectID()
self.avatar_id.deserialize(bit_stream)
self.given_inventory_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_inventory_ids.append(object_id)
self.given_item_slot_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_item_slot_ids.append(object_id)
