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)