def to_binary(self, write_version=None): if write_version is None: write_version = self.bam_version dg = Datagram() self.write(write_version, dg) if self.extra_data: dg.append_data(self.extra_data) return dg.get_message()
def load(self, f): if f.read(len(self.HEADER)) != self.HEADER: raise BAMException('Invalid BAM header.') dg = Datagram(f.read()) di = DatagramIterator(dg) self.header_size = di.get_uint32() self.bam_major_ver = di.get_uint16() self.bam_minor_ver = di.get_uint16() self.version = (self.bam_major_ver, self.bam_minor_ver) self.read_long_pointers = False self.type_handles = {} self.file_datas = [] self.objects.clear() if self.version >= (5, 0): self.file_endian = di.get_uint8() else: self.file_endian = 1 if self.version >= (6, 27): self.stdfloat_double = di.get_bool() else: self.stdfloat_double = False self.nesting_level = 0 self.unknown_handles = [] self.object_map = {} self.pta_map = {} # New object stream format: read object hierarchy while di.getRemainingSize() > 0: self.read_object_code(di)
def add_message(self, channel, sender, di): message = Message( self.get_timestamp(), channel, sender, di.get_uint16(), io.NetworkDatagram(Datagram(di.get_remaining_bytes()))) message.setup() self._messages.append(message)
def requestLogin(self, username, password): sender = self.air.getMsgSender() dg = self.air.getDatagram(Datagram()) ip = NetDatagram(dg).getAddress() if self.isValidAccount(username, password): self.d_loginAccepted(sender, ip) else: self.d_loginRejected(sender)
def task_read_polling(self, task): if self.reader.dataAvailable(): logging.debug('data available from server') datagram = Datagram() if self.reader.getData(datagram): logging.debug('received data from server: %s', datagram) logging.debug('received data from server: %s', datagram.getMessage()) # TODO: provide a way to supply a data callback self._data_last_received = 0 else: # no data received logging.debug('no data') self._data_last_received += self.get_dt() if self._data_last_received >= 10: logging.error('connection to server lost') return return task.cont
def fromNetString(self, data): self.seenTips = [] dg = Datagram(data) dgi = DatagramIterator(dg) # up to 255 tips numTips = dgi.getUint8() for i in xrange(numTips): tipId = dgi.getUint8() self.seenTips.append(tipId)
def buildPacket(self, _opcode, _managerCode=None): pkt = Datagram() pkt.addUint8(_opcode) if _managerCode == MOVE_MANAGER: pkt.addUint8(_managerCode) if _managerCode == MOTD: pkt.addUint8(_managerCode) # MOTD code return pkt
def toNetString(self): dg = Datagram() dg.addUint8(len(self.seenTips)) for tipId in self.seenTips: dg.addUint8(tipId) dgi = DatagramIterator(dg) return dgi.getRemainingBytes()
def load_object(self, obj): self.obj_id = obj['obj_id'] dg = Datagram(obj['data']) di = DatagramIterator(dg) self.load(di) if di.get_remaining_size() > 0: self.extra_data = di.get_remaining_bytes() if self.bam_file.warn_truncated_data: logging.warning( 'Warning! Loading truncated data for {0}.'.format( obj['handle_name']))
def writeRegisterPacket(self, _data): # Build a packet pkt = Datagram() # Type of packet pkt.addUint8(MSG_REGISTER) pkt.addString(str(_data)) return pkt
def write_object(self, dg, opcode, obj=None, written_handles=None): obj_dg = Datagram() if self.version >= (6, 21): obj_dg.add_uint8(opcode) if obj is not None: self.write_handle(obj_dg, obj['handle_id'], written_handles) write_pointer(obj_dg, obj['obj_id']) obj_dg.appendData(obj['data']) self.write_datagram(obj_dg, dg)
def loadMap(self): # Load map from bytes-file file_data = open('tracks.trk', 'rb').read() data = Datagram(file_data) iterator = DatagramIterator(data) is_color = False mm = 0 maps, map, row, tile = [], [], [], [] x, y, z = 0, 0, 0 for i in range(iterator.getRemainingSize()): n = iterator.getUint8() if mm <= 2: # gravity and drains map.append(n) mm += 1 else: if is_color: is_color = False part.append(n) tile.append(part) else: if n < 64: part = [n] is_color = True else: if n == 64: tile.append(P) z += 1 if n == 65: x += 1 row.append(tile) tile = [] if n == 66: mm = 0 x = y = z = 0 maps.append(map) map, row, tile = [], [], [] if x >= 9: x = 0 y += 1 map.append(row) row = [] self.maps = maps self.currentMap = 0 self.getMap()
def handle_control_message(self, di): channel = di.get_uint64() if channel == types.CONTROL_MESSAGE: message_type = di.get_uint16() sender = di.get_uint64() if message_type == types.CONTROL_SET_CHANNEL: # only set this participants channel once this is due, # because the client agent registers it's own connections... if not self.channel: self.channel = sender self.network.interface.add_channel(self, sender) elif message_type == types.CONTROL_REMOVE_CHANNEL: self.network.interface.remove_channel(sender) # attempt to handle any pending post removes for the channel # that we are removing here, this is because the client agent # will send this message when a client disconnects... self.handle_post_removes(sender) elif message_type == types.CONTROL_ADD_POST_REMOVE: # check to see if the post remove message actually # has post remove data... if not di.get_remaining_size(): self.notify.warning( 'Cannot add post remove for channel: %d, ' 'no data is remaining in the buffer!' % sender) return self.network.interface.add_post_remove( sender, io.NetworkDatagram(Datagram(di.get_remaining_bytes()))) elif message_type == types.CONTROL_CLEAR_POST_REMOVE: self.network.interface.remove_post_remove(sender) else: self.network.message_interface.add_message(channel, di.get_uint64(), di)
def write_object(self, dg, opcode, obj=None, written_handles=None): obj_dg = Datagram() if self.version >= (6, 21): obj_dg.add_uint8(opcode) if obj is not None: obj_id = obj['obj_id'] instance = self.object_map.get(obj_id) self.write_handle(obj_dg, obj['handle_id'], written_handles) self.write_pointer(obj_dg, obj_id) if instance: instance.write_object(self.version, obj) obj_dg.appendData(obj['data']) self.write_datagram(obj_dg, dg)
def writerCallback(self): # if there are no events queued, return None if not self.eventQueue: return None # collect data data = [] for event in self.eventQueue: data.append(event.toMessage()) self.eventQueue = [] # make a message for the events myPyDatagram = Datagram() myPyDatagram.add_uint8(NetworkManager.MessageEnum.EVENT) datastring = json.dumps(data) print(datastring) myPyDatagram.add_string(datastring) print("server: writer callback") return myPyDatagram
def write_object(self, write_version, obj): dg = Datagram() self.write(write_version, dg) obj['data'] = dg.get_message()
def saveMap(self): # Save map to bytes-file self.rememberMap() data = Datagram() no_part = 64 next_tile = 65 next_map = 66 for m, map in enumerate(self.maps): if len(map) >= 1: data.addUint8(map[0]) # gravity data.addUint8(map[1]) # fuel-drain data.addUint8(map[2]) # o2-drain map = map[3:] for y in map: for x in y: for z in x: if z == P: data.addUint8(no_part) else: data.addUint8(z[0]) data.addUint8(z[1]) data.addUint8(next_tile) data.addUint8(next_map) with open('tracks.trk', 'wb') as outfile: outfile.write(bytes(data))
def write(self, f, target_version): dg = Datagram() dg.appendData(self.HEADER) if target_version >= (6, 27): header_size = 6 elif target_version >= (5, 0): header_size = 5 else: header_size = 4 bam_major_ver, bam_minor_ver = target_version dg.add_uint32(header_size) dg.add_uint16(bam_major_ver) dg.add_uint16(bam_minor_ver) if header_size >= 5: dg.add_uint8(self.file_endian) if header_size >= 6: dg.add_bool(self.stdfloat_double) written_handles = [] if self.objects: self.write_object(dg, BOC_push, self.objects[0], written_handles) for obj in self.objects[1:]: self.write_object(dg, BOC_adjunct, obj, written_handles) for data in self.file_datas: self.write_file_data(dg, data) if self.version >= (6, 21): self.write_object(dg, BOC_pop) f.write(dg.getMessage())
def SendMessage(self): print( "{}: sending message to server".format(self.name) ) myPyDatagram=Datagram() self.cWriter.send(myPyDatagram,self.myConnection)
def heartbeat(self ): myPyDatagram=Datagram() print("server: sending heartbeat to {} clients".format(len(self.activeConnections) ) ) self.BroadcastMessage( myPyDatagram )
def load_object(self, obj): dg = Datagram(obj['data']) di = DatagramIterator(dg) self.load(di)
def write(self, f): dg = Datagram() dg.appendData(self.HEADER) if self.version >= (6, 27): header_size = 6 elif self.version >= (5, 0): header_size = 5 else: header_size = 4 bam_major_ver, bam_minor_ver = self.version dg.add_uint32(header_size) dg.add_uint16(bam_major_ver) dg.add_uint16(bam_minor_ver) if header_size >= 5: dg.add_uint8(self.file_endian) if header_size >= 6: dg.add_bool(self.stdfloat_double) self.written_handles = [] self.write_long_pointers = False if self.objects: objects = list(self.objects.values()) self.write_object(dg, BamGlobals.BOC_push, objects[0], self.written_handles) for obj in objects[1:]: self.write_object(dg, BamGlobals.BOC_adjunct, obj, self.written_handles) for data in self.file_datas: self.write_file_data(dg, data) if self.version >= (6, 21): self.write_object(dg, BamGlobals.BOC_pop) f.write(dg.getMessage())
def process_modules(self): # TODO: Compression dg = Datagram() dg.addUint32(len(self.modules)) for moduleName in self.modules: data, size = self.modules[moduleName] dg.addString(moduleName) dg.addInt32(size) dg.appendData(data) data = dg.getMessage() iv = self.generate_key(16) key = self.generate_key(16) fixed_key = ''.join( chr((i ^ (7 * i + 16)) % ((i + 5) * 3)) for i in xrange(16)) fixed_iv = ''.join( chr((i ^ (2 * i + 53)) % ((i + 9) * 6)) for i in xrange(16)) securekeyandiv = aes.encrypt(iv + key, fixed_key, fixed_iv) return securekeyandiv + aes.encrypt(data, key, iv)
def read_datagram(self, di): num_bytes = di.get_uint32() data = di.extractBytes(num_bytes) dg = Datagram(data) return dg