def cleanup(self): logger.debug("Cleaning up PRUDP socket") self.state = STATE_DISCONNECTED self.stop_ping() if self.socket_event: scheduler.remove(self.socket_event) self.stream.cleanup()
def handle_ack(self, payload): ack_id = struct.unpack_from(">I", payload, -4)[0] if ack_id in self.messages: message = self.messages.pop(ack_id) scheduler.remove(message.timeout) else: logger.warning("Received ack with unknown ack id: %i", ack_id)
def handle_recv(self, data): if not data: logger.debug("(%i) Connection was closed" % self.local_session_id) self.state = self.DISCONNECTED self.remove_events() return packets = self.packet_encoder.decode(data) for packet in packets: logger.debug("(%i) Packet received: %s" % (self.local_session_id, packet)) if not self.check_session_id(packet): continue if packet.flags & FLAG_ACK: if packet.packet_id in self.ack_events: logger.debug("(%i) Packet acknowledged: %s" % (self.local_session_id, packet)) if packet.type == TYPE_SYN: self.target_signature = packet.signature elif packet.type == TYPE_CONNECT: if self.state == self.CONNECTING: if not self.validate_connection_response( packet.payload): self.state = self.DISCONNECTED self.remove_events() return scheduler.remove(self.ack_events.pop(packet.packet_id)) elif packet.flags & FLAG_MULTI_ACK: if self.transport_type != self.settings.TRANSPORT_UDP or packet.multi_ack_version == 1: ack_id = struct.unpack_from("<H", packet.payload, 2)[0] else: ack_id = struct.unpack("<H", packet.payload)[0] logger.debug("(%i) Aggregate ack up to packet %i" % (self.local_session_id, ack_id)) for packet_id in list(self.ack_events.keys()): if packet_id <= ack_id: scheduler.remove(self.ack_events.pop(packet_id)) else: if packet.packet_id >= self.packet_id_in: self.packet_queue[packet.packet_id] = packet while self.packet_id_in in self.packet_queue: packet = self.packet_queue.pop(self.packet_id_in) if not self.handle_packet(packet): return self.packet_id_in += 1 if packet.flags & FLAG_NEED_ACK: self.send_ack(packet) if packet.type == TYPE_DISCONNECT: self.send_ack(packet) self.send_ack(packet) if self.ping_event: self.ping_event.reset() self.timeout_event.reset()
def handle_timeout(self, handle): handle.counter += 1 if handle.counter == handle.limit: logger.warning("Removing message from queue because its resend limit was reached") self.messages.pop(handle.ack_id) scheduler.remove(handle.timeout) else: logger.debug("Resending message with ack_id=%i" %handle.ack_id) self.transport.send(handle.station, handle.message)
def handle_timeout(self, message): logger.debug("Resending message") message.limit -= 1 if message.limit == 0: scheduler.remove(message.event) del self.packets[message.ack_id] else: self.transport.send(message.station, message.message)
def acknowledge(self, station, ack_id): if ack_id not in self.packets: logger.warning("Received ack with unknown ack id") return message = self.packets[ack_id] if message.station != station: logger.warning("Received ack from wrong station") return scheduler.remove(message.event) del self.packets[ack_id]
def handle_recv(self, data): if not data: logger.debug("Connection was closed") scheduler.remove(self.socket_event) return stream = streams.StreamIn(data, self.settings) length = stream.u32() protocol_id = stream.u8() if protocol_id & 0x80: self.handle_request(protocol_id & 0x7F, stream) else: self.handle_response(protocol_id, stream)
def remove_events(self): scheduler.remove(self.socket_event) scheduler.remove(self.timeout_event) if self.ping_event: scheduler.remove(self.ping_event) for event in self.ack_events.values(): scheduler.remove(event)
def close(self): if self.state != self.DISCONNECTED: self.state = self.DISCONNECTING scheduler.remove(self.ping_event) self.ping_event = None packet = PRUDPPacket(TYPE_DISCONNECT, FLAG_RELIABLE | FLAG_NEED_ACK) self.send_packet(packet) self.wait_ack(packet) self.s.close() self.state = self.DISCONNECTED self.remove_events() logger.debug("(%i) PRUDP connection closed", self.session_id)
def handle_recv(self, data): if not data: logger.debug("Connection was closed") scheduler.remove(self.socket_event) return message = RMCMessage.parse(self.settings, data) if message.mode == RMCMessage.REQUEST: context = RMCContext(self, self.pid) response = self.handle_request(context, message) self.sock.send(response.encode()) else: if message.error != -1: logger.warning("RMC failed with error code 0x%08X", message.error) else: logger.debug( "Received RMC response: protocol=%i, call=%i, method=%i", message.protocol, message.call_id, message.method) self.responses[message.call_id] = message
def handle_connection_denied(self, station): if station.rvcid in self.pending_connect: self.results[station.rvcid] = self.RESULT_DENIED scheduler.remove(self.timeouts.pop(station.rvcid)) self.pending_connect.remove(station.rvcid)
def handle_station_connected(self, station): if station.rvcid in self.pending_connect: logger.info("Successfully connected to station") self.pending_connect.remove(station.rvcid) self.results[station.rvcid] = self.RESULT_OK scheduler.remove(self.timeouts.pop(station.rvcid))
def close(self): scheduler.remove(self.socket_event) self.client.close()
def acknowledge(self, key, packet): event, block = self.ack_events.pop(key) scheduler.remove(event) if block: self.ack_packets[key] = packet
def cleanup(self): if self.socket_event: scheduler.remove(self.socket_event) for event, block in self.ack_events.values(): scheduler.remove(event) self.ack_events = {}
def stop_ping(self): if self.ping_event: scheduler.remove(self.ping_event) self.ping_event = None
def cleanup(self): scheduler.remove(self.event) self.socket.close()
def stop(self): if self.event: scheduler.remove(self.event) self.s.close() self.event = None
def cleanup(self): scheduler.remove(self.event) self.transport.cleanup()
def close(self): if self.socket_event: scheduler.remove(self.socket_event) self.sock.close()
def handle_ack(self, packet_id): if packet_id in self.messages: message = self.messages.pop(packet_id) scheduler.remove(message.timeout)
def close(self): if self.is_connected(): scheduler.remove(self.socket_event) self.client.close()