Requeue packets on network error

[kpp]

    // Get a packet from the queue, and try to encapsulate it
    fn send_queued_packet<'a>(&self, dst: &'a mut [u8]) -> TunnResult<'a> {
        if let Some(packet) = self.dequeue_packet() {
            match self.tunnel_to_network(&packet, dst) {
                TunnResult::Err(_) => {
                    // On error, return packet to the queue
                    self.requeue_packet(packet);
                }
                r => return r,
            }
        }
        TunnResult::Done
}

https://github.com/cloudflare/boringtun/blob/master/src/noise/mod.rs#L220

[kurnevsky]

tunnel_to_network returns error only if there is no session. It seems it's auxiliary method that has nothing to do with socket errors. See: https://github.com/cloudflare/boringtun/blob/e765e12613e8eb33e39e7fb0676ad5797c02c5f6/src/noise/mod.rs#L150

Or do I miss something?

[kpp]

It's an example of a pattern. Instead of dropping a packet we can requeue it to try to send it when we are online again

[kurnevsky]

Almost all packets expire quite fast. It just doesn't make sense to store them if we can't send them immediately. The only packets that don't expire that come in mind - lossless net crypto packets. But for them we have different mechanism - we store them to a buffer and drop only when other side confirms that they are delivered. So I don't really see where we can apply it.

[kpp]

TCP client - need to reconnect to the server and create a new secure session.
DHT - does not matter. We will bootstrap again
lossless net crypto packets - we have a mechanism to confirm they are delivered

Seems you are right.