aria2-protocol 0.3.9

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::*;

const MAX_PENDING_PACKETS: usize = 1024;
const MAX_SELECTIVE_ACK_BYTES: usize = 252;

impl UtpConnection {
    pub(super) fn handle_data_packet(
        &mut self,
        packet: &UtpPacket,
    ) -> Result<PacketHandling, ConnectionError> {
        self.receive_sequenced(packet)
    }

    pub(super) fn handle_fin_packet(
        &mut self,
        packet: &UtpPacket,
    ) -> Result<PacketHandling, ConnectionError> {
        self.receive_sequenced(packet)
    }

    fn receive_sequenced(&mut self, packet: &UtpPacket) -> Result<PacketHandling, ConnectionError> {
        if !matches!(
            self.state,
            ConnectionState::Established | ConnectionState::FinWait | ConnectionState::Closing
        ) {
            return Err(ConnectionError::NotConnected);
        }
        let extensions = packet.parse_extensions()?;
        let (acknowledged, fast_retransmit) =
            self.acknowledge_sent(packet, extensions.selective_ack)?;
        let distance = packet.seq_nr.wrapping_sub(self.ack_nr);
        let is_fin = packet.packet_type().ok() == Some(PacketType::StFin);
        if self.state != ConnectionState::Closing
            && (!self.remote_fin_received || is_fin)
            && distance > 0
            && distance < 0x8000
        {
            let free = RECV_BUFFER_SIZE
                .saturating_sub(self.recv_buffer.len() + self.pending_receive_bytes);
            if distance == 1 && extensions.application_payload.len() <= free {
                self.deliver_packet(packet, extensions.application_payload);
                while self.state != ConnectionState::Closing
                    && self.state != ConnectionState::Closed
                {
                    let next = self.ack_nr.wrapping_add(1);
                    let Some(packet) = self.pending_receive.remove(&next) else {
                        break;
                    };
                    self.pending_receive_bytes -= packet.payload.len();
                    self.deliver_packet(&packet, &packet.payload);
                }
            } else if distance > 1
                && self.pending_receive.len() < MAX_PENDING_PACKETS
                && extensions.application_payload.len() <= free
                && self.pending_receive_bytes + extensions.application_payload.len()
                    <= RECV_BUFFER_SIZE / 2
                && !self.pending_receive.contains_key(&packet.seq_nr)
            {
                self.pending_receive_bytes += extensions.application_payload.len();
                let mut packet = packet.clone();
                packet.extension = 0;
                packet.payload = extensions.application_payload.to_vec();
                self.pending_receive.insert(packet.seq_nr, packet);
            }
        }
        self.update_receive_window();
        Ok(PacketHandling {
            response_packets: vec![self.state_packet()],
            acknowledged,
            fast_retransmit,
        })
    }

    fn deliver_packet(&mut self, packet: &UtpPacket, payload: &[u8]) {
        self.ack_nr = packet.seq_nr;
        if packet.packet_type().ok() == Some(PacketType::StFin) {
            self.remote_fin_received = true;
            self.state = if self.local_fin_acked {
                ConnectionState::Closed
            } else if self.state == ConnectionState::FinWait {
                ConnectionState::FinWait
            } else {
                ConnectionState::Closing
            };
            self.pending_receive.clear();
            self.pending_receive_bytes = 0;
        } else {
            self.recv_buffer.extend_from_slice(payload);
        }
    }

    pub(super) fn add_selective_ack(&self, packet: &mut UtpPacket) {
        let Some(mask) = self.selective_ack_mask() else {
            return;
        };
        packet.set_selective_ack(&mask);
    }

    fn selective_ack_mask(&self) -> Option<Vec<u8>> {
        let highest_bit = self
            .pending_receive
            .keys()
            .filter_map(|sequence| {
                let distance = sequence.wrapping_sub(self.ack_nr);
                if distance > 1 && distance < 0x8000 {
                    Some(usize::from(distance) - 2)
                } else {
                    None
                }
            })
            .filter(|bit| *bit < MAX_SELECTIVE_ACK_BYTES * 8)
            .max()?;
        let mask_length = (highest_bit / 8 + 1).div_ceil(4) * 4;
        let mut mask = vec![0; mask_length.min(MAX_SELECTIVE_ACK_BYTES)];

        for sequence in self.pending_receive.keys() {
            let distance = sequence.wrapping_sub(self.ack_nr);
            if distance <= 1 || distance >= 0x8000 {
                continue;
            }
            let bit = usize::from(distance) - 2;
            if bit < mask.len() * 8 {
                mask[bit / 8] |= 1 << (bit % 8);
            }
        }

        Some(mask)
    }

    pub(super) fn update_receive_window(&mut self) {
        self.recv_window = RECV_BUFFER_SIZE
            .saturating_sub(self.recv_buffer.len() + self.pending_receive_bytes)
            as u32;
    }
}