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()
