refactor: pass single ALPN around instead of ALPN list

This way there is always exactly one ALPN ("imap" or "smtp").

src/imap/client.rs

@@ -105,7 +105,7 @@ impl Client {
         strict_tls: bool,
     ) -> Result<Self> {
         let tls_stream =
-            connect_tls(context, hostname, port, IMAP_TIMEOUT, strict_tls, &["imap"]).await?;
+            connect_tls(context, hostname, port, IMAP_TIMEOUT, strict_tls, "imap").await?;
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
         let mut client = Client::new(session_stream);
@@ -153,7 +153,7 @@ impl Client {
         let socks5_stream = socks5_config
             .connect(context, domain, port, IMAP_TIMEOUT, strict_tls)
             .await?;
-        let tls_stream = wrap_tls(strict_tls, domain, &["imap"], socks5_stream).await?;
+        let tls_stream = wrap_tls(strict_tls, domain, "imap", socks5_stream).await?;
         let buffered_stream = BufWriter::new(tls_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
         let mut client = Client::new(session_stream);
@@ -208,7 +208,7 @@ impl Client {
         let buffered_socks5_stream = client.into_inner();
         let socks5_stream: Socks5Stream<_> = buffered_socks5_stream.into_inner();
 
-        let tls_stream = wrap_tls(strict_tls, hostname, &["imap"], socks5_stream)
+        let tls_stream = wrap_tls(strict_tls, hostname, "imap", socks5_stream)
             .await
             .context("STARTTLS upgrade failed")?;
         let buffered_stream = BufWriter::new(tls_stream);

src/net.rs

@@ -53,10 +53,10 @@ async fn connect_tls_inner(
     timeout_val: Duration,
     host: &str,
     strict_tls: bool,
-    alpns: &[&str],
+    alpn: &str,
 ) -> Result<TlsStream<Pin<Box<TimeoutStream<TcpStream>>>>> {
     let tcp_stream = connect_tcp_inner(addr, timeout_val).await?;
-    let tls_stream = wrap_tls(strict_tls, host, alpns, tcp_stream).await?;
+    let tls_stream = wrap_tls(strict_tls, host, alpn, tcp_stream).await?;
     Ok(tls_stream)
 }
 
@@ -101,14 +101,14 @@ pub(crate) async fn connect_tls(
     port: u16,
     timeout_val: Duration,
     strict_tls: bool,
-    alpns: &[&str],
+    alpn: &str,
 ) -> Result<TlsStream<Pin<Box<TimeoutStream<TcpStream>>>>> {
     let mut first_error = None;
 
     for resolved_addr in
         lookup_host_with_cache(context, host, port, timeout_val, strict_tls).await?
     {
-        match connect_tls_inner(resolved_addr, timeout_val, host, strict_tls, alpns).await {
+        match connect_tls_inner(resolved_addr, timeout_val, host, strict_tls, alpn).await {
             Ok(tls_stream) => {
                 if strict_tls {
                     dns::update_connect_timestamp(context, host, &resolved_addr.ip().to_string())
@@ -148,7 +148,7 @@ async fn connect_starttls_imap_inner(
     let buffered_tcp_stream = client.into_inner();
     let tcp_stream = buffered_tcp_stream.into_inner();
 
-    let tls_stream = wrap_tls(strict_tls, host, &["imap"], tcp_stream)
+    let tls_stream = wrap_tls(strict_tls, host, "imap", tcp_stream)
         .await
         .context("STARTTLS upgrade failed")?;
 
@@ -197,7 +197,7 @@ async fn connect_starttls_smtp_inner(
     let client = async_smtp::SmtpClient::new().smtp_utf8(true);
     let transport = async_smtp::SmtpTransport::new(client, BufStream::new(tcp_stream)).await?;
     let tcp_stream = transport.starttls().await?.into_inner();
-    let tls_stream = wrap_tls(strict_tls, host, &["smtp"], tcp_stream)
+    let tls_stream = wrap_tls(strict_tls, host, "smtp", tcp_stream)
         .await
         .context("STARTTLS upgrade failed")?;
     Ok(tls_stream)

src/net/tls.rs

@@ -32,10 +32,10 @@ pub fn build_tls(strict_tls: bool, alpns: &[&str]) -> TlsConnector {
 pub async fn wrap_tls<T: AsyncRead + AsyncWrite + Unpin>(
     strict_tls: bool,
     hostname: &str,
-    alpns: &[&str],
+    alpn: &str,
     stream: T,
 ) -> Result<TlsStream<T>> {
-    let tls = build_tls(strict_tls, alpns);
+    let tls = build_tls(strict_tls, &[alpn]);
     let tls_stream = tls.connect(hostname, stream).await?;
     Ok(tls_stream)
 }

src/smtp.rs

@@ -120,7 +120,7 @@ impl Smtp {
         let socks5_stream = socks5_config
             .connect(context, hostname, port, SMTP_TIMEOUT, strict_tls)
             .await?;
-        let tls_stream = wrap_tls(strict_tls, hostname, &["smtp"], socks5_stream).await?;
+        let tls_stream = wrap_tls(strict_tls, hostname, "smtp", socks5_stream).await?;
         let buffered_stream = BufStream::new(tls_stream);
         let session_stream: Box<dyn SessionBufStream> = Box::new(buffered_stream);
         let client = smtp::SmtpClient::new().smtp_utf8(true);
@@ -144,7 +144,7 @@ impl Smtp {
         let client = smtp::SmtpClient::new().smtp_utf8(true);
         let transport = SmtpTransport::new(client, BufStream::new(socks5_stream)).await?;
         let tcp_stream = transport.starttls().await?.into_inner();
-        let tls_stream = wrap_tls(strict_tls, hostname, &["smtp"], tcp_stream)
+        let tls_stream = wrap_tls(strict_tls, hostname, "smtp", tcp_stream)
             .await
             .context("STARTTLS upgrade failed")?;
         let buffered_stream = BufStream::new(tls_stream);
@@ -179,7 +179,7 @@ impl Smtp {
         strict_tls: bool,
     ) -> Result<SmtpTransport<Box<dyn SessionBufStream>>> {
         let tls_stream =
-            connect_tls(context, hostname, port, SMTP_TIMEOUT, strict_tls, &["smtp"]).await?;
+            connect_tls(context, hostname, port, SMTP_TIMEOUT, strict_tls, "smtp").await?;
         let buffered_stream = BufStream::new(tls_stream);
         let session_stream: Box<dyn SessionBufStream> = Box::new(buffered_stream);
         let client = smtp::SmtpClient::new().smtp_utf8(true);