Skip to main content

register_alpn_handler

Function register_alpn_handler 

Source
pub async fn register_alpn_handler(
    listener: TcpListener,
    config: Option<AlpnHandlerConfig>,
) -> Result<ManagedTlsListener>
Examples found in repository?
examples/pebble_local.rs (line 24)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let listener = TcpListener::bind("127.0.0.1:8443").await?;
11    let mut config = AlpnHandlerConfig::for_host("api.test")?;
12    config.public_ip_addresses = vec!["127.0.0.1".parse()?];
13    config.verify_dns_before_issuance = false;
14    config.cert_store_directory = PathBuf::from("./certs");
15    config.acme_endpoint = AcmeEndpoint::Pebble(ManagedPebbleConfig {
16            pebble_bind: "127.0.0.1:14000".parse::<SocketAddr>()?,
17            pebble_executable: None,
18            working_directory: None,
19            state_directory: Some(PathBuf::from("./certs/pebble-state")),
20        });
21    config.events = EventOutput::Stderr;
22    config.allow_non_443_listener = true;
23    config.local_fallback_enabled = true;
24    let mut listener = register_alpn_handler(listener, Some(config)).await?;
25    while let Some(connection) = listener.accept().await? { tokio::spawn(async move { drop(connection.into_stream()); }); }
26    Ok(())
27}
More examples
Hide additional examples
examples/letsencrypt_prod.rs (line 27)
14async fn main() -> Result<(), Box<dyn std::error::Error>> {
15    let host = "api.example.com";
16    let public_ip: IpAddr = "203.0.113.10".parse()?;
17    let listener = TcpListener::bind("0.0.0.0:443").await?;
18    let mut config = AlpnHandlerConfig::for_host(&host)?;
19    config.public_ip_addresses = vec![public_ip];
20    config.dns_servers = Some(vec!["udp://1.1.1.1:53".parse::<DnsServer>()?, "udp://8.8.8.8:53".parse::<DnsServer>()?]);
21    config.verify_dns_before_issuance = true;
22    config.cert_store_directory = PathBuf::from("./certs");
23    config.acme_endpoint = AcmeEndpoint::LetsEncrypt(LetsEncryptAcmeProfile::Production);
24    config.acme_contacts = vec!["mailto:ops@example.com".into()];
25    config.events = EventOutput::Stderr;
26    config.local_fallback_enabled = true;
27    let mut alpn_listener = register_alpn_handler(listener, Some(config)).await?;
28    tokio::spawn(async move {
29        while let Ok(Some(connection)) = alpn_listener.accept().await {
30            // Process incoming ACME/HTTPS traffic on 443 here, or close it if
31            // this application only needs port 443 for certificate issuance.
32            drop(connection.into_stream());
33        }
34    });
35
36    // Your LDAP-over-TLS service belongs here. The handler selects the
37    // certificate already obtained through 443, so LDAP clients on 636 do not
38    // need to know anything about ACME.
39    let ldap_listener = TcpListener::bind("0.0.0.0:636").await?;
40    let mut ldap_listener = register_handler(ldap_listener).await?;
41    while let Some(connection) = ldap_listener.accept().await? {
42        tokio::spawn(async move { drop(connection.into_stream()); });
43    }
44    Ok(())
45}
examples/letsencrypt_staging.rs (line 27)
14async fn main() -> Result<(), Box<dyn std::error::Error>> {
15    let host = "api.example.com";
16    let public_ip: IpAddr = "203.0.113.10".parse()?;
17    let listener = TcpListener::bind("0.0.0.0:443").await?;
18    let mut config = AlpnHandlerConfig::for_host(&host)?;
19    config.public_ip_addresses = vec![public_ip];
20    config.dns_servers = Some(vec!["udp://1.1.1.1:53".parse::<DnsServer>()?, "udp://8.8.8.8:53".parse::<DnsServer>()?]);
21    config.verify_dns_before_issuance = true;
22    config.cert_store_directory = PathBuf::from("./certs");
23    config.acme_endpoint = AcmeEndpoint::LetsEncrypt(LetsEncryptAcmeProfile::Staging);
24    config.acme_contacts = vec!["mailto:ops@example.com".into()];
25    config.events = EventOutput::Subscribe;
26    config.local_fallback_enabled = true;
27    let mut alpn_listener = register_alpn_handler(listener, Some(config)).await?;
28    let mut events = subscribe_events()?;
29    tokio::spawn(async move { while let Ok(Some(event)) = events.recv().await { eprintln!("staging event: {event}"); } });
30    tokio::spawn(async move {
31        while let Ok(Some(connection)) = alpn_listener.accept().await {
32            // Process incoming ACME/HTTPS traffic on 443 here, or close it if
33            // this application only needs port 443 for certificate issuance.
34            drop(connection.into_stream());
35        }
36    });
37
38    // Run the real LDAP-over-TLS service on 636. It transparently uses the
39    // certificate issued and cached by the 443 ACME listener.
40    let ldap_listener = TcpListener::bind("0.0.0.0:636").await?;
41    let mut ldap_listener = register_handler(ldap_listener).await?;
42    while let Some(connection) = ldap_listener.accept().await? {
43        tokio::spawn(async move { drop(connection.into_stream()); });
44    }
45    Ok(())
46}