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 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 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
