DualStack/Multiple IPs

[MTRNord]

Hi :)

Just wondering: How can I listen to both ipv4 and ipv6 at the same time?

[jplatte]

Usually just listening on IPv6 will actually listen on both (depending on OS / configuration), have you tried that?

[jplatte]

Right, that's one solution. The other (maybe a bit more efficient) would be using hyper::Server::builder to supply a custom incoming-connection stream that wraps two sockets rather than just one. There's a simple one for UDS in the unix-domain-socket example, but overall I think this part of hyper isn't documented that well.

@davidpdrsn wdyt about having another example for this kind of thing?

[davidpdrsn]

wdyt about having another example for this kind of thing?

Sounds good 👍

[jplatte]

@davidpdrsn do you have a hint on which types would need to be composed for that custom acceptor? I'm not very well-versed in that stuff.

[davidpdrsn]

Something like this should do it

use axum::{routing::get, Router};
use hyper::server::{accept::Accept, conn::AddrIncoming};
use std::{
    net::{Ipv4Addr, Ipv6Addr, SocketAddr},
    pin::Pin,
    task::{Context, Poll},
};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, World!" }));

    let localhost_v4 = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 8080);
    let incoming_v4 = AddrIncoming::bind(&localhost_v4).unwrap();

    let localhost_v6 = SocketAddr::new(Ipv6Addr::LOCALHOST.into(), 8080);
    let incoming_v6 = AddrIncoming::bind(&localhost_v6).unwrap();

    let combined = CombinedIncoming {
        a: incoming_v4,
        b: incoming_v6,
    };

    axum::Server::builder(combined)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

struct CombinedIncoming {
    a: AddrIncoming,
    b: AddrIncoming,
}

impl Accept for CombinedIncoming {
    type Conn = <AddrIncoming as Accept>::Conn;
    type Error = <AddrIncoming as Accept>::Error;

    fn poll_accept(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
        if let Poll::Ready(Some(value)) = Pin::new(&mut self.a).poll_accept(cx) {
            return Poll::Ready(Some(value));
        }

        if let Poll::Ready(Some(value)) = Pin::new(&mut self.b).poll_accept(cx) {
            return Poll::Ready(Some(value));
        }

        Poll::Pending
    }
}

[alcroito]

Latest hyper 1.x removed the hyper::server::{accept::Accept, conn::AddrIncoming}; types in https://github.com/hyperium/hyper/pull/2929/files#diff-aadba6c11b5c1bdda47d1b62c33da2e8dce94f2e77bcd5b99cb8279aaa8671f8L16

There's a mention of alternatives being available in the future in the hyper-util crate, but current docs don't seem to have such alternatives: https://docs.rs/hyper-util/latest/hyper_util/server/conn/auto/index.html

Is there any other way of achieving this now?