Add Tokio Support

[ghenry]

Hi,

Thanks for this crate!

Using from_std and socket2 I can set the options I need like I do in C, but do you have any experience with tokio and your crate?

I set these options myself in my C code, but I'm porting it to Rust: https://github.com/SentryPeer/SentryPeer/blob/3d9317a216a7a877e2e99aece445558e23ca52ad/src/sip_daemon.c#L331

Thanks,
Gavin.

[pixsperdavid]

This crate was made primarily for use with the mdns_sd crate (see keepsimple1/mdns-sd#65), which doesn't use tokio so async support was not considered. It may not be impossible to add however. I will convert this to a feature suggestion.

[ghenry]

Thanks. Chats have been had here tokio-rs/tokio#799 (comment) about try_io which I'm going to try or I'll create an Ext style Trait.

[sinhpham]

This is a rough cut of what I have for Tokio support:

use std::{
    io,
    net::SocketAddr
};

use socket2::{Domain, SockAddr};
use socket_pktinfo::{PktInfo, PktInfoUdpSocket};
use tokio::io::unix::AsyncFd;

/// Async wrapper for PktInfoUdpSocket using tokio's AsyncFd
pub(crate) struct AsyncPktInfoUdpSocket {
    inner: AsyncFd<PktInfoUdpSocket>,
}

impl AsyncPktInfoUdpSocket {
    pub(crate) fn new(domain: Domain) -> io::Result<Self> {
        let socket = PktInfoUdpSocket::new(domain)?;
        socket.set_nonblocking(true)?;
        Ok(Self {
            inner: AsyncFd::new(socket)?,
        })
    }

    pub(crate) fn bind(&self, addr: &SocketAddr) -> io::Result<()> {
        let sock_addr = SockAddr::from(*addr);
        self.inner.get_ref().bind(&sock_addr)
    }

    pub(crate) async fn send_to(&self, buf: &[u8], addr: &SocketAddr) -> io::Result<usize> {
        let sock_addr = SockAddr::from(*addr);
        loop {
            let mut guard = self.inner.writable().await?;

            match guard.try_io(|inner| inner.get_ref().send_to(buf, &sock_addr)) {
                Ok(result) => return result,
                Err(_would_block) => continue,
            }
        }
    }

    pub(crate) async fn recv(&self, buf: &mut [u8]) -> io::Result<(usize, PktInfo)> {
        loop {
            let mut guard = self.inner.readable().await?;

            match guard.try_io(|inner| inner.get_ref().recv(buf)) {
                Ok(result) => return result,
                Err(_would_block) => continue,
            }
        }
    }
}

If this seems like a good fit for the project, I’d be happy to put together a PR. Just let me know.

[ghenry]

Looks good. I ended up doing this which still needs to be expanded https://crates.io/crates/tokio-dstip

[pixsperdavid]

@sinhpham Looks good, happy to add it if you can create a PR, however you can put behind a non-default 'tokio' feature so there's no default dependency on tokio.

[keepsimple1]

Using from_std and socket2 I can set the options I need like I do in C, but do you have any experience with tokio and your crate?

One approach is to convert PktInfoUdpSocket into a std UdpSocket. Say, add this method:

    /// Converts this PktInfoUdpSocket into a std UdpSocket.
    pub fn into_std(self) -> std::net::UdpSocket {
        self.socket.into()
    }

Then we can use this std UdpSocket with from_std in tokio (as mentioned above). And we don't have to pull in tokio dependency.