Handle `alt_svc` `host`

[mxinden]

AltSvc host and port are currently unused, i.e. not taken into consideration.

happy-eyeballs/src/lib.rs

Lines 446 to 454 in eb44d87

	/// Alternative service information from previous connections.
	///
	/// See [RFC 7838](https://datatracker.ietf.org/doc/html/rfc7838).
	#[derive(Debug, Clone)]
	pub struct AltSvc {
	pub host: Option<String>,
	pub port: Option<u16>,
	pub protocol: HttpVersion,
	}

I don't think it is trivial how host and port should be handled in relation to HTTPS RR, A and AAAA, i.e. should they be treated like we treat a positive AAAA? Should they be a hint? ...?

[mxinden]

Related discussion:

https://www.ietf.org/archive/id/draft-thomson-httpbis-alt-svcb-00.html

[KershawChang]

I'd like to work on this one.

The behavior I'd like to propose is below. For alt-svc hosts, we only send AAAA/A queries — no HTTPS RR lookup.
I think doing HTTPS query for alt-svc host adds too much complexity.

Key behaviors shown in the test:

• DNS queries for alt-svc hosts are sent first (AAAA, A only), then origin (HTTPS, AAAA, A)
• Alt-svc connection attempts don't wait for origin move-on conditions — they fire as soon as the alt-svc host
  resolves
• Alt-svc endpoints are preferred over origin fallback

#[test]
fn alt_svc_single_host() {
    let now = Instant::now();
    let config = NetworkConfig {
        http_versions: HttpVersions::default(),
        ip: IpPreference::DualStackPreferV6,
        alt_svc: vec![AltSvc {
            host: Some("alt1.example.com".into()),
            port: Some(4433),
            http_version: HttpVersion::H3,
        }],
    };
    let mut he = HappyEyeballs::new_with_network_config(HOSTNAME, PORT, config).unwrap();

    he.expect(
        vec![
            (
                None,
                Some(Output::SendDnsQuery {
                    id: Id::from(0),
                    hostname: "alt1.example.com".into(),
                    record_type: DnsRecordType::Aaaa,
                }),
            ),
            (
                None,
                Some(Output::SendDnsQuery {
                    id: Id::from(1),
                    hostname: "alt1.example.com".into(),
                    record_type: DnsRecordType::A,
                }),
            ),
            (None, Some(out_send_dns_https(Id::from(2)))),
            (None, Some(out_send_dns_aaaa(Id::from(3)))),
            (None, Some(out_send_dns_a(Id::from(4)))),
        ],
        now,
    );

    he.expect(
        vec![
            (
                Some(Input::DnsResult {
                    id: Id::from(0),
                    result: DnsResult::Aaaa(Ok(vec![V6_ADDR_2])),
                }),
                Some(Output::AttemptConnection {
                    id: Id::from(5),
                    endpoint: Endpoint {
                        address: SocketAddr::new(V6_ADDR_2.into(), 4433),
                        http_version: ConnectionAttemptHttpVersions::H3,
                        ech_config: None,
                    },
                }),
            ),
            (None, Some(out_connection_attempt_delay())),
        ],
        now,
    );

    let later = now + CONNECTION_ATTEMPT_DELAY;
    he.expect(
        vec![
            (Some(in_dns_https_negative(Id::from(2))), None),
            (
                Some(in_dns_aaaa_positive(Id::from(3))),
                Some(out_attempt_v6_h1_h2(Id::from(6))),
            ),
            (None, Some(out_connection_attempt_delay())),
        ],
        later,
    );

    let later2 = later + CONNECTION_ATTEMPT_DELAY;
    he.expect(
        vec![
            (
                Some(Input::DnsResult {
                    id: Id::from(1),
                    result: DnsResult::A(Ok(vec![V4_ADDR_2])),
                }),
                Some(Output::AttemptConnection {
                    id: Id::from(7),
                    endpoint: Endpoint {
                        address: SocketAddr::new(V4_ADDR_2.into(), 4433),
                        http_version: ConnectionAttemptHttpVersions::H3,
                        ech_config: None,
                    },
                }),
            ),
            (None, Some(out_connection_attempt_delay())),
        ],
        later2,
    );

    let later3 = later2 + CONNECTION_ATTEMPT_DELAY;
    he.expect(
        vec![
            (
                Some(in_dns_a_positive(Id::from(4))),
                Some(out_attempt_v4_h1_h2(Id::from(8))),
            ),
            (None, Some(out_connection_attempt_delay())),
        ],
        later3,
    );

    let later4 = later3 + CONNECTION_ATTEMPT_DELAY;
    he.expect(vec![(None, None)], later4);
}

[zirngibl]

How would ECH be handled if no HTTPS queries are done? Could this result in a potential downgrade if Alt-Svc information is cached but HTTPS records not updated?

[mxinden]

Good point @zirngibl.

Kershaw and I suggest as a first patch:

• don't implement alt-svc ip and domain for now
• implement alt-svc port
• have https record port take precedence over alt-svc port
• do connection attempts to both.

Later on we can implement all the details in https://www.rfc-editor.org/rfc/rfc9460.html?utm_source=chatgpt.com#section-9.3.