def CheckDataReceived(self):
if len(self.buffer_in) >= 24:
mstart = self.buffer_in[:24]
ms = StreamManager.GetStream(mstart)
reader = BinaryReader(ms)
try:
m = Message()
m.Magic = reader.ReadUInt32()
m.Command = reader.ReadFixedString(12).decode('utf-8')
m.Length = reader.ReadUInt32()
m.Checksum = reader.ReadUInt32()
self.pm = m
except Exception as e:
self.Log('could not read initial bytes %s ' % e)
finally:
StreamManager.ReleaseStream(ms)
del reader
try:
#make this threadsafe
# reactor.callFromThread(self.CheckMessageData)
self.CheckMessageData()
except RecursionError:
self.Log("Recursion error!!!")
self.Disconnect()
def DeserializeFromAsyncSocket(socket, cancellation_token):
buffer = bytearray(24)
try:
socket.recv_into(buffer, 24)
ms = MemoryStream(buffer)
reader = BinaryReader(ms)
message = Message()
message.Magic = reader.ReadUInt32()
message.Command = reader.ReadFixedString(12).decode('utf-8')
length = reader.ReadUInt32()
if length > Message.PayloadMaxSizeInt:
raise Exception("format too big")
message.Checksum = reader.ReadUInt32()
message.Payload = bytearray(length)
if length > 0:
message.Payload = Message.FillBufferAsyncStream(
socket, length, None)
checksum = Message.GetChecksum(message.Payload)
if checksum != message.Checksum:
print("Message command :%s " % message.Command)
print("Checksum mismatch: %s " % message.Checksum)
print("message payload: %s " % message.Payload)
raise Exception("invalid checksum")
return message
except Exception as e:
print("could not receive buffer from socket: %s " % e)
def CheckDataReceived(self):
currentLength = len(self.buffer_in)
if currentLength < 24:
return
# Extract the message header from the buffer, and return if not enough
# buffer to fully deserialize the message object.
try:
# Construct message
mstart = self.buffer_in[:24]
ms = StreamManager.GetStream(mstart)
reader = BinaryReader(ms)
m = Message()
# Extract message metadata
m.Magic = reader.ReadUInt32()
m.Command = reader.ReadFixedString(12).decode('utf-8')
m.Length = reader.ReadUInt32()
m.Checksum = reader.ReadUInt32()
# Return if not enough buffer to fully deserialize object.
messageExpectedLength = 24 + m.Length
# percentcomplete = int(100 * (currentLength / messageExpectedLength))
# self.Log("Receiving %s data: %s percent complete" % (m.Command, percentcomplete))
if currentLength < messageExpectedLength:
return
except Exception as e:
self.Log('Error: Could not read initial bytes %s ' % e)
return
finally:
StreamManager.ReleaseStream(ms)
del reader
# The message header was successfully extracted, and we have enough enough buffer
# to extract the full payload
try:
# Extract message bytes from buffer and truncate buffer
mdata = self.buffer_in[:messageExpectedLength]
self.buffer_in = self.buffer_in[messageExpectedLength:]
# Deserialize message with payload
stream = StreamManager.GetStream(mdata)
reader = BinaryReader(stream)
message = Message()
message.Deserialize(reader)
# Propagate new message
self.MessageReceived(message)
except Exception as e:
self.Log('Error: Could not extract message: %s ' % e)
return
finally:
StreamManager.ReleaseStream(stream)
# Finally, after a message has been fully deserialized and propagated,
# check if another message can be extracted with the current buffer:
if len(self.buffer_in) >= 24:
self.CheckDataReceived()
