From 7a67efa8689273c81b69a46cbd5a9984d593289a Mon Sep 17 00:00:00 2001
From: travis laduke <travisladuke@gmail.com>
Date: Tue, 28 Mar 2023 14:51:03 -0700
Subject: [PATCH] Fail the app when binding to a port fails

tokio is was eating the panics and continuing on
with no socket listening on 53

making tokio crash would take a bunch of rewrite
i think, so i moved the `bind` calls out to a different,
non-async fn
---
 src/init.rs          | 16 +++++++++++-----
 src/server.rs        | 16 ++++++++++++----
 tests/service/mod.rs | 17 ++++++++++++++++-
 3 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/src/init.rs b/src/init.rs
index 70fe5fa..c350984 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -222,11 +222,17 @@ impl Launcher {
                     None
                 };
 
-                tokio::spawn(
-                    server
-                        .clone()
-                        .listen(ip, Duration::new(1, 0), tls_cert, chain, key),
-                );
+                let (tcp_socket, udp_socket) = Server::bind(ip).await?;
+
+                tokio::spawn(server.clone().listen(
+                    ip,
+                    Duration::new(1, 0),
+                    tls_cert,
+                    chain,
+                    key,
+                    tcp_socket,
+                    udp_socket,
+                ));
             }
 
             return Ok(ztauthority);
diff --git a/src/server.rs b/src/server.rs
index 22d6205..914e768 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -2,6 +2,7 @@ use std::{
     net::{IpAddr, SocketAddr},
     time::Duration,
 };
+use anyhow::Context;
 use tracing::info;
 
 use openssl::{
@@ -23,6 +24,15 @@ impl Server {
         Self(zt)
     }
 
+    pub async fn bind(ip: IpAddr) -> Result<(TcpListener, UdpSocket), anyhow::Error> {
+        let sa = SocketAddr::new(ip, 53);
+
+        let tcp = TcpListener::bind(sa).await.with_context(|| "Failed to bind TCP port 53")?;
+        let udp = UdpSocket::bind(sa).await.with_context(|| "Failed to bind UDP port 53")?;
+
+        return Ok((tcp, udp));
+    }
+
     // listener routine for TCP and UDP.
     pub async fn listen(
         self,
@@ -31,11 +41,9 @@ impl Server {
         certs: Option<X509>,
         cert_chain: Option<Stack<X509>>,
         key: Option<PKey<Private>>,
+        tcp: TcpListener,
+        udp: UdpSocket,
     ) -> Result<(), anyhow::Error> {
-        let sa = SocketAddr::new(ip, 53);
-        let tcp = TcpListener::bind(sa).await?;
-        let udp = UdpSocket::bind(sa).await?;
-
         let mut sf = ServerFuture::new(init_catalog(self.0).await?);
 
         if let (Some(certs), Some(key)) = (certs.clone(), key.clone()) {
diff --git a/tests/service/mod.rs b/tests/service/mod.rs
index 9051ea1..31c4b4e 100644
--- a/tests/service/mod.rs
+++ b/tests/service/mod.rs
@@ -239,8 +239,23 @@ impl Service {
 
         for ip in listen_ips.clone() {
             let server = Server::new(ztauthority.to_owned());
+
+            let (tcp_socket, udp_socket) = match Server::bind(ip.ip()).await {
+                Ok(x) => x,
+                Err(e) => {
+                    panic!("Could not bind port. {}", e);
+                }
+            };
             info!("Serving {}", ip.clone());
-            tokio::spawn(server.listen(ip.ip(), Duration::new(1, 0), None, None, None));
+            tokio::spawn(server.listen(
+                ip.ip(),
+                Duration::new(1, 0),
+                None,
+                None,
+                None,
+                tcp_socket,
+                udp_socket,
+            ));
         }
 
         listen_ips