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 update(self, timestamp):
if not self.isActive and (self.lastUpdate + 10) < timestamp:
self.disconnect("timeout")
return
self.isActive = False
if len(self.ackQueue) > 0:
pk = Ack()
pk.packets = self.ackQueue
self.sendPacket(pk)
self.ackQueue = []
if len(self.nackQueue) > 0:
pk = Nack()
pk.packets = self.nackQueue
self.sendPacket(pk)
self.nackQueue = []
if len(self.packetToSend) > 0:
limit = 16
for count, pk in enumerate(self.packetToSend):
pk.sendTime = timestamp
pk.encode()
self.recoveryQueue[pk.sequenceNumber] = pk
del self.packetToSend[count]
self.sendPacket(pk)
limit -= 1
if limit <= 0:
break
if len(self.packetToSend) > 2048:
self.packetToSend = []
for seq, pk in dict(self.recoveryQueue).items():
if pk.sendTime < (timeNow() - 8):
self.packetToSend.append(pk)
del self.recoveryQueue[seq]
self.sendTheQueue()
def __init__(self, server, mtuSize, address):
self.server = server
self.mtuSize = mtuSize
self.address = address
self.lastUpdate = int(timeNow())
for i in range(0, 32):
self.channelIndex.insert(i, 0)
def addToQueue(self, pk, flags = priority["Normal"]):
priority = flags & 0b0000111
if pk.needAck and pk.messageIndex is not None:
self.needAck[pk.identifierAck] = pk.messageIndex
if priority == self.priority["Immediate"]:
packet = DataPacket()
packet.sequenceNumber = self.sendSequenceNumber
self.sendSequenceNumber += 1
if pk.needAck:
packet.packets.append(deepcopy(pk))
pk.needAck = False
else:
packet.packets.append(pk.toBinary())
self.sendPacket(packet)
packet.sendTime = timeNow()
self.recoveryQueue[packet.sequenceNumber] = packet
return
length = len(self.sendQueue)
if (length + pk.getTotalLength()) > self.mtuSize:
self.sendTheQueue()
if pk.needAck:
self.sendQueue.packets.append(deepcopy(pk))
pk.needACK = False
else:
self.sendQueue.packets.append(pk.toBinary())
def tick(self):
if not self.shutdown:
for token, connection in self.connections.items():
connection.update(timeNow())
else:
return
sleep(self.raknetTickLength)
def sendTheQueue(self):
if len(self.sendQueue.packets) > 0:
self.sendQueue.sequenceNumber = self.sendSequenceNumber
self.sendSequenceNumber += 1
self.sendPacket(self.sendQueue)
self.sendQueue.sendTime = timeNow()
self.recoveryQueue[self.sendQueue.sequenceNumber] = self.sendQueue
self.sendQueue = DataPacket()
def run(self):
while True:
buffer = self.socket.receiveBuffer()
if buffer is not None:
data, address = buffer
self.handle(data, InternetAddress(address[0], address[1]))
if not self.shutdown:
for token in self.connections:
self.connections[token].update(timeNow())
sleep(self.raknetTickLength)
def receive(self, buffer):
self.isActive = True
self.lastUpdate = timeNow()
header = buffer[0]
if (header & 0x80) == 0:
return
if header & 0x40:
return self.handleAck(buffer)
if header & 0x20:
return self.handleNack(buffer)
return self.handleDatagram(buffer)
def receive(self, buffer):
self.isActive = True
self.lastUpdate = timeNow()
header = buffer[0]
if (header & BitFlags.Valid) == 0:
return
if header & BitFlags.Ack:
return self.handleAck(buffer)
if header & BitFlags.Nack:
return self.handleNack(buffer)
else:
return self.handleDatagram(buffer)
def handleNack(self, buffer):
packet = Nack()
packet.buffer = buffer
packet.decode()
for seq in packet.packets:
if seq in self.recoveryQueue:
pk = self.recoveryQueue[seq]
pk.sequenceNumber = self.sendSequenceNumber
self.sendSequenceNumber += 1
pk.sendTime = timeNow()
pk.encode()
self.sendPacket(pk)
del self.recoveryQueue[seq]
def addToQueue(self, pk, flags=priority["Normal"]):
priority = flags & 0b1
if priority == self.priority["Immediate"]:
packet = DataPacket()
packet.sequenceNumber = self.sendSequenceNumber
self.sendSequenceNumber += 1
packet.packets.append(pk)
self.sendPacket(packet)
packet.sendTime = timeNow()
self.recoveryQueue[packet.sequenceNumber] = packet
return
length = self.sendQueue.length()
if (length + pk.getTotalLength()) > self.mtuSize:
self.sendTheQueue()
self.sendQueue.packets.append(pk)
def update(self, timestamp):
if not self.isActive and (self.lastUpdate + 10000) < timestamp:
self.disconnect("timeout")
return
self.isActive = False
if len(self.ackQueue) > 0:
pk = Ack()
pk.packets = self.ackQueue
self.sendPacket(pk)
self.ackQueue = []
if len(self.nackQueue) > 0:
pk = Nack()
pk.packets = self.nackQueue
self.sendPacket(pk)
self.nackQueue = []
if len(self.packetToSend) > 0:
limit = 16
for key, pk in enumerate(self.packetToSend):
pk.sendTime = timestamp
pk.encode()
self.recoveryQueue[pk.sequenceNumber] = pk
del self.packetToSend[key]
#self.sendPacket(pk) #ToDo
limit -= 1
if limit <= 0:
break
if len(self.packetToSend) > 2048:
self.packetToSend = []
if len(self.needAck) > 0:
for identifierACK, indexes in self.needAck.items():
if len(indexes) == 0:
del self.needAck[identifierACK]
# Todo add Notify ACK
for seq, pk in dict(self.recoveryQueue).items():
if pk.sendTime < (timeNow() - 8):
self.packetToSend.append(pk)
del self.recoveryQueue[seq]
# Should look at that later
for seq, value in enumerate(self.receivedWindow):
if seq < self.windowStart:
del self.receivedWindow[seq]
else:
break
self.sendTheQueue()
def __init__(self):
self.BOARD = "BOARD"
self.BCM = "BCM"
self.OUT = "output"
self.IN = "input"
self.mode = self.BOARD
self.physicalToGPIO = {
3: 2,
5: 3,
7: 4,
8: 14,
10: 15,
11: 17,
12: 18,
13: 27,
15: 22,
16: 23,
18: 24,
19: 10,
21: 9,
22: 25,
23: 11,
24: 8,
26: 7,
27: 0,
28: 1,
29: 5,
31: 6,
32: 12,
33: 13,
35: 19,
36: 16,
37: 26,
38: 20,
40: 21
}
self.GPIOtoPhysical = {
gpio: phys
for phys, gpio in self.physicalToGPIO.iteritems()
}
self.startTime = timeNow()
def log(self, msg):
print("T+" + str(timeNow() - self.startTime) + " | " + msg)
def __init__(self, server, mtuSize, address):
self.server = server
self.mtuSize = mtuSize
self.address = address
self.lastUpdate = int(timeNow())
self.channelIndex = [0] * 32
