Listen on IPv6, also?

[troelsarvin]

My server has both IPv4 and IPv6, and I want Axum to listen to both types of protocol on all interfaces.

The following results in an Axum which is available on port 3000 via IPv4 only. How can I make it available on IPv6, also?

    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();

[SamuelBonilla]

Try with:

let addr = ":::3000".parse().unwrap();
axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();

or

let addr = ":::3000".parse::<std::net::SocketAddr>().unwrap();
axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();

[jplatte]

I went down the rabbit hole, looks like it was briefly discussed (mostly bc. there's an inconsistency in defaults on Windows and Linux) but nothing happened in response 😥

See tokio-rs/tokio-core#227 and the Rust PR linked from that.

The socket2 crate (and net2 before it) allows configuring this, although according to one comment in that tokio issue this wouldn't work on BSD which forces the compat stuff on. No idea about macOS. Plus hyper doesn't use that in Server::bind so it doesn't matter for this specific case anyways.

[troelsarvin]

@paolobarbolini, for the record:

    let addr = ":::3000".parse::<std::net::SocketAddr>().unwrap();

does not work. It has to be the following way where the address part is encluded in square brackets:

    let addr = "[::]:3000".parse::<std::net::SocketAddr>().unwrap();

[borrow-checker]

Alternative if you like using constants not strings

let addr = &SocketAddr::new(IpAddr::from(Ipv6Addr::UNSPECIFIED), 3000);

Note that just like the string version Ipv6Addr::UNSPECIFIED refers to both ipv4 and ipv6 in this context.

[llllvvuu]

Note that :: / Ipv6Addr::UNSPECIFIED may or may not be ideal, since it's different from "both IPv4 and IPv6", it may also expose the service publicly: https://stackoverflow.com/a/72541698

[borrow-checker]

It's not different from both IPv4 and IPv6 as in Axum specifying [::] (which is equivalent to Ipv6Addr::UNSPECIFIED) then making a IpAddr with it assumes both v4 and v6 any.

[jplatte]

I would imagine that this would work:

const PORT = 3000;

let svc = app.into_make_service();

let addr4 = SocketAddr::from((Ipv4Addr::UNSPECIFIED, PORT));
let addr6 = SocketAddr::from((Ipv6Addr::UNSPECIFIED, PORT));

let server4 = axum::Server::bind(&addr4).serve(svc.clone());
let server6 = axum::Server::bind(&addr6).serve(svc);

let (res4, res6) = futures_util::future::join(server4, server6).await;
res4.unwrap();
res6.unwrap();

[troelsarvin]

It doesn't work, which is odd:

    let app = Router::new().route("/", get(handler));

    const PORT: u16 = 3000;
    let addr_ipv4 = net::SocketAddr::from((net::Ipv4Addr::UNSPECIFIED, PORT));
    let addr_ipv6 = net::SocketAddr::from((net::Ipv6Addr::UNSPECIFIED, PORT));
    println!("addr_ipv4: {:?}", addr_ipv4);
    println!("addr_ipv6: {:?}", addr_ipv6);

    let svc = app.into_make_service();
    let server4 = axum::Server::bind(&addr_ipv4).serve(svc.clone());
    let server6 = axum::Server::bind(&addr_ipv6).serve(svc);
    let (res4, res6) = futures_util::future::join(server4, server6).await;
    res4.unwrap();
    res6.unwrap();

Results in:

addr_ipv4: 0.0.0.0:3000
addr_ipv6: [::]:3000
thread 'tokio-runtime-worker' panicked at 'error binding to [::]:3000: error creating server listener: Address already in use (os error 98)', /home/troels/.cargo/registry/src/github.com-1ecc6299db9ec823/hyper-0.14.17/src/server/server.rs:87:17
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

I guess it's because binding to a :: IPv6 address has a strange side effect of also binding the 0.0.0.0 IPv4 interface. This is on Fedora Linux 35.

[troelsarvin]

By the way, in relation to this, https://serverfault.com/a/39561/15081 describes well how this is OS dependent, and on Linux behavior can be adjusted in /proc/sys/net/ipv6/bindv6only
Perhaps, if one wants exact control on Linux, one has to inspect /proc/sys/net/ipv6/bindv6only and act accordingly, but I think in practice almost all situations will benefit from just being able to bind "::" and get both IPv4 and IPv6.