def handlePacket(self, packet):
if packet.split:
self.handleSplit(packet)
return
id = packet.buffer[0]
dataPacket = None
pk = None
sendPacket = None
if id < 0x80:
if self.state == self.status["Connecting"]:
if id == PacketIdentifiers.ConnectionRequest:
dataPacket = ConnectionRequest()
dataPacket.buffer = packet.buffer
dataPacket.decode()
pk = ConnectionRequestAccepted()
pk.clientAddress = self.address
pk.systemIndex = 0
pk.requestTime = dataPacket.time
pk.time = Binary.flipLongEndianness(int(timeNow())) if Binary.ENDIANNESS == Binary.LITTLE_ENDIAN else int(timeNow())
pk.encode()
sendPacket = EncapsulatedPacket()
sendPacket.reliability = 0
sendPacket.buffer = pk.buffer
self.addToQueue(sendPacket, self.priority["Immediate"])
elif id == PacketIdentifiers.NewIncomingConnection:
dataPacket = NewIncomingConnection()
dataPacket.buffer = packet.buffer
dataPacket.decode()
serverPort = self.server.socket.address.port
if dataPacket.address.port == serverPort:
self.state = status["Connected"]
self.server.interface.onOpenConnection(self)
elif id == PacketIdentifiers.DisconnectNotification:
self.disconnect('client disconnect')
elif id == PacketIdentifiers.ConnectedPing:
dataPacket = ConnectedPing()
dataPacket.buffer = packet.buffer
dataPacket.decode()
pk = ConnectedPong()
pk.pingTime = dataPacket.time
pk.pongTime = Binary.flipLongEndianness(int(timeNow())) if Binary.ENDIANNESS == Binary.LITTLE_ENDIAN else int(timeNow())
pk.encode()
sendPacket = EncapsulatedPacket()
sendPacket.reliability = 0
sendPacket.buffer = pk.buffer
self.addToQueue(sendPacket)
elif self.state == self.status["Connected"]:
self.interface.onEncapsulated(packet, self.address)
def decodePayload(self):
self.sequenceNumber = self.getLTriad()
while not self.feof():
self.packets.append(EncapsulatedPacket.fromBinary(self))
def close(self):
self.addEncapsulatedToQueue(
EncapsulatedPacket.fromBinary(BinaryStream(b"\x00\x00\x08\x15")),
self.priority["Immediate"])
def close(self):
self.addEncapsulatedToQueue(EncapsulatedPacket.fromBinary('\x00\x00\x08\x15'), self.priority["Immediate"])
def addEncapsulatedToQueue(self, packet, flags = priority["Normal"]):
packet.needAck = flags & 0b00001000
if packet.needAck > 0:
self.needAck[packet.identifierACK] = []
if 2 <= packet.reliability <= 7:
packet.messageIndex = self.messageIndex
self.messageIndex += 1
if packet.reliability == 3:
packet.orderIndex = self.channelIndex[packet.orderChannel]
self.channelIndex[packet.orderChannel] += 1
if packet.getTotalLength() + 4 > self.mtuSize:
buffers = []
for i in range(0, len(packet.buffer), self.mtuSize - 34):
buffers.append(packet.buffer[i:i - (self.mtuSize - 34)])
self.splitId += 1
splitId = self.splitId % 65536
for count, buffer in enumerate(buffers):
pk = EncapsulatedPacket()
pk.splitId = splitId
pk.split = True
pk.splitCount = len(buffers)
pk.reliability = packet.reliability
pk.splitIndex = count
pk.buffer = buffer
if count > 0:
pk.messageIndex = self.messageIndex
self.messageIndex += 1
else:
pk.messageIndex = packet.messageIndex
if pk.reliability == 3:
pk.orderChannel = packet.orderChannel
pk.orderIndex = packet.orderIndex
self.addToQueue(pk, flags | self.priority["Immediate"])
else:
self.addToQueue(packet, flags)
