Clone for ServerConfig too

And test for clone/debug on our types

src/server.rs

@@ -94,6 +94,7 @@ pub trait ResolvesServerCert : Send + Sync {
 ///
 /// Making one of these can be expensive, and should be
 /// once per process rather than once per connection.
+#[derive(Clone)]
 pub struct ServerConfig {
     /// List of ciphersuites, in preference order.
     pub ciphersuites: Vec<&'static SupportedCipherSuite>,
@@ -104,13 +105,13 @@ pub struct ServerConfig {
     pub ignore_client_order: bool,
 
     /// How to store client sessions.
-    pub session_storage: Mutex<Box<StoresServerSessions + Send>>,
+    pub session_storage: Arc<Mutex<Box<StoresServerSessions + Send>>>,
 
     /// How to produce tickets.
-    pub ticketer: Box<ProducesTickets>,
+    pub ticketer: Arc<ProducesTickets>,
 
     /// How to choose a server cert and key.
-    pub cert_resolver: Box<ResolvesServerCert>,
+    pub cert_resolver: Arc<ResolvesServerCert>,
 
     /// Protocol names we support, most preferred first.
     /// If empty we don't do ALPN at all.
@@ -131,7 +132,7 @@ pub struct ServerConfig {
     pub versions: Vec<ProtocolVersion>,
 
     /// How to verify client certificates.
-    verifier: Box<verify::ClientCertVerifier>,
+    verifier: Arc<verify::ClientCertVerifier>,
 }
 
 /// Something which never stores sessions.
@@ -265,15 +266,15 @@ impl ServerConfig {
         ServerConfig {
             ciphersuites: ALL_CIPHERSUITES.to_vec(),
             ignore_client_order: false,
-            session_storage: Mutex::new(Box::new(NoSessionStorage {})),
-            ticketer: Box::new(NeverProducesTickets {}),
+            session_storage: Arc::new(Mutex::new(Box::new(NoSessionStorage {}))),
+            ticketer: Arc::new(NeverProducesTickets {}),
             alpn_protocols: Vec::new(),
-            cert_resolver: Box::new(FailResolveChain {}),
+            cert_resolver: Arc::new(FailResolveChain {}),
             client_auth_roots: anchors::RootCertStore::empty(),
             client_auth_offer: false,
             client_auth_mandatory: false,
             versions: vec![ ProtocolVersion::TLSv1_3, ProtocolVersion::TLSv1_2 ],
-            verifier: Box::new(verify::WebPKIVerifier {}),
+            verifier: Arc::new(verify::WebPKIVerifier {}),
         }
     }
 
@@ -284,7 +285,7 @@ impl ServerConfig {
 
     /// Sets the session persistence layer to `persist`.
     pub fn set_persistence(&mut self, persist: Box<StoresServerSessions + Send>) {
-        self.session_storage = Mutex::new(persist);
+        self.session_storage = Arc::new(Mutex::new(persist));
     }
 
     /// Sets a single certificate chain and matching private key.  This
@@ -296,7 +297,7 @@ impl ServerConfig {
     pub fn set_single_cert(&mut self,
                            cert_chain: Vec<key::Certificate>,
                            key_der: key::PrivateKey) {
-        self.cert_resolver = Box::new(AlwaysResolvesChain::new_rsa(cert_chain, &key_der));
+        self.cert_resolver = Arc::new(AlwaysResolvesChain::new_rsa(cert_chain, &key_der));
     }
 
     /// Set the ALPN protocol list to the given protocol names.

src/ticketer.rs

@@ -4,7 +4,7 @@ use rand;
 
 use time;
 use std::mem;
-use std::sync::Mutex;
+use std::sync::{Mutex, Arc};
 use ring::aead;
 
 /// This is a `ProducesTickets` implementation which uses
@@ -188,7 +188,7 @@ impl Ticketer {
     /// with a 12 hour life and randomly generated keys.
     ///
     /// The encryption mechanism used in Chacha20Poly1305.
-    pub fn new() -> Box<ProducesTickets> {
-        Box::new(TicketSwitcher::new(6 * 60 * 60, generate_inner))
+    pub fn new() -> Arc<ProducesTickets> {
+        Arc::new(TicketSwitcher::new(6 * 60 * 60, generate_inner))
     }
 }

tests/api.rs

@@ -387,7 +387,7 @@ fn server_cert_resolve_with_sni() {
     let client_config = make_client_config();
     let mut server_config = make_server_config();
 
-    server_config.cert_resolver = Box::new(ServerCheckCertResolve::new("the-value-from-sni"));
+    server_config.cert_resolver = Arc::new(ServerCheckCertResolve::new("the-value-from-sni"));
 
     let mut client = ClientSession::new(&Arc::new(client_config), "the-value-from-sni");
     let mut server = ServerSession::new(&Arc::new(server_config));
@@ -757,3 +757,25 @@ fn server_stream_read() {
         check_read(&mut stream, b"world");
     }
 }
+
+#[test]
+fn server_config_is_clone() {
+    make_server_config().clone();
+}
+
+#[test]
+fn client_config_is_clone() {
+    make_client_config().clone();
+}
+
+#[test]
+fn client_session_is_debug() {
+    let client = ClientSession::new(&Arc::new(make_client_config()), "localhost");
+    println!("{:?}", client);
+}
+
+#[test]
+fn server_session_is_debug() {
+    let server = ServerSession::new(&Arc::new(make_server_config()));
+    println!("{:?}", server);
+}