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