Add support for creating LDAP clients from existing TcpStream and `…

…UnixStream`.

That allows to create LDAP client from file descriptor and
handle connection (with ssl) in sandboxed environemtn.

examples/bind_sync.rs

@@ -1,5 +1,5 @@
 // Demonstrates synchronously connecting, binding to,
-// and disconnectiong from the server.
+// and disconnection from the server.
 
 use ldap3::result::Result;
 use ldap3::LdapConn;

examples/bind_sync_from_exiting_tcp_stream.rs

@@ -0,0 +1,18 @@
+// Demonstrates synchronously connecting, binding to,
+// and disconnection from the exiting tcp stream.
+
+use ldap3::result::Result;
+use ldap3::{LdapConn, LdapConnSettings};
+use std::net::TcpStream;
+use url::Url;
+
+fn main() -> Result<()> {
+    let stream = TcpStream::connect("localhost:2389")?;
+
+    let url = Url::parse("ldap://localhost:2389").unwrap();
+    let mut ldap = LdapConn::from_tcp_stream(stream, LdapConnSettings::new(), &url)?;
+    let _res = ldap
+        .simple_bind("cn=Manager,dc=example,dc=org", "secret")?
+        .success()?;
+    Ok(ldap.unbind()?)
+}

src/conn.rs

@@ -396,6 +396,38 @@ impl LdapConnAsync {
         Self::from_url_with_settings(LdapConnSettings::new(), url).await
     }
 
+    /// Create a connection to an LDAP server from existing UnixStream.
+    #[cfg(unix)]
+    pub fn from_unix_stream(stream: UnixStream) -> (Self, Ldap) {
+        Self::conn_pair(ConnType::Unix(stream))
+    }
+
+    /// Create a connection to an LDAP server from existing UnixStream.
+    #[cfg(not(unix))]
+    pub fn from_unix_stream(stream: UnixStream) -> (Self, Ldap) {
+        unimplemented!("no Unix domain sockets on non-Unix platforms");
+    }
+
+    /// Create a connection to an LDAP server from existing TcpStream,
+    /// specified by an already parsed `Url`, using
+    /// `settings` to specify additional parameters.
+    pub async fn from_tcp_stream(
+        stream: TcpStream,
+        settings: LdapConnSettings,
+        url: &Url,
+    ) -> Result<(Self, Ldap)> {
+        let mut settings = settings;
+        let timeout = settings.conn_timeout.take();
+
+        let (scheme, hostname, _host_port) = Self::extract_scheme_host_port(url, &settings)?;
+        let conn_future = Self::new_tcp_stream(stream, scheme, hostname, settings);
+        if let Some(timeout) = timeout {
+            time::timeout(timeout, conn_future).await?
+        } else {
+            conn_future.await
+        }
+    }
+
     #[cfg(unix)]
     async fn new_unix(url: &Url, _settings: LdapConnSettings) -> Result<(Self, Ldap)> {
         let path = url.host_str().unwrap_or("");
@@ -415,8 +447,10 @@ impl LdapConnAsync {
         unimplemented!("no Unix domain sockets on non-Unix platforms");
     }
 
-    #[allow(unused_mut)]
-    async fn new_tcp(url: &Url, mut settings: LdapConnSettings) -> Result<(Self, Ldap)> {
+    fn extract_scheme_host_port<'a>(
+        url: &'a Url,
+        settings: &LdapConnSettings,
+    ) -> Result<(&'a str, &'a str, String)> {
         let mut port = 389;
         let scheme = match url.scheme() {
             s @ "ldap" => {
@@ -428,7 +462,6 @@ impl LdapConnAsync {
             }
             #[cfg(any(feature = "tls-native", feature = "tls-rustls"))]
             s @ "ldaps" => {
-                settings = settings.set_starttls(false);
                 port = 636;
                 s
             }
@@ -437,12 +470,26 @@ impl LdapConnAsync {
         if let Some(url_port) = url.port() {
             port = url_port;
         }
-        let (_hostname, host_port) = match url.host_str() {
+        let (hostname, host_port) = match url.host_str() {
             Some(h) if !h.is_empty() => (h, format!("{}:{}", h, port)),
             Some(h) if !h.is_empty() => ("localhost", format!("localhost:{}", port)),
             _ => panic!("unexpected None from url.host_str()"),
         };
+        Ok((scheme, hostname, host_port))
+    }
+
+    async fn new_tcp(url: &Url, settings: LdapConnSettings) -> Result<(Self, Ldap)> {
+        let (scheme, hostname, host_port) = Self::extract_scheme_host_port(url, &settings)?;
         let stream = TcpStream::connect(host_port.as_str()).await?;
+        Self::new_tcp_stream(stream, scheme, hostname, settings).await
+    }
+
+    async fn new_tcp_stream(
+        stream: TcpStream,
+        scheme: &str,
+        hostname: &str,
+        settings: LdapConnSettings,
+    ) -> Result<(Self, Ldap)> {
         let (mut conn, mut ldap) = Self::conn_pair(ConnType::Tcp(stream));
         match scheme {
             "ldap" => (),
@@ -465,7 +512,7 @@ impl LdapConnAsync {
                 }
                 let parts = conn.stream.into_parts();
                 let tls_stream = if let ConnType::Tcp(stream) = parts.io {
-                    LdapConnAsync::create_tls_stream(settings, _hostname, stream).await?
+                    LdapConnAsync::create_tls_stream(settings, hostname, stream).await?
                 } else {
                     panic!("underlying stream not TCP");
                 };

src/sync.rs

@@ -1,5 +1,8 @@
 use std::collections::HashSet;
 use std::hash::Hash;
+use std::net::TcpStream;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
 use std::time::Duration;
 
 use crate::adapters::IntoAdapterVec;
@@ -69,6 +72,53 @@ impl LdapConn {
         Ok(LdapConn { ldap, rt })
     }
 
+    /// Create a connection to an LDAP server from existing UnixStream.
+    #[cfg(unix)]
+    pub fn from_unix_stream(stream: UnixStream) -> Result<Self> {
+        let stream = tokio::net::UnixStream::from_std(stream)?;
+        let rt = runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()?;
+
+        let ldap = rt.block_on(async move {
+            let (conn, ldap) = LdapConnAsync::from_unix_stream(stream);
+            super::drive!(conn);
+            ldap
+        });
+        Ok(LdapConn { ldap, rt })
+    }
+
+    /// Create a connection to an LDAP server from existing UnixStream.
+    #[cfg(not(unix))]
+    pub fn from_unix_stream(stream: UnixStream) -> Result<Self> {
+        unimplemented!("no Unix domain sockets on non-Unix platforms");
+    }
+
+    /// Create a connection to an LDAP server from existing TcpStream,
+    /// specified by an already parsed `Url`, using
+    /// `settings` to specify additional parameters.
+    pub fn from_tcp_stream(
+        stream: TcpStream,
+        settings: LdapConnSettings,
+        url: &Url,
+    ) -> Result<Self> {
+        let rt = runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()?;
+
+        let ldap = rt.block_on(async move {
+            stream.set_nonblocking(true)?;
+            let stream = tokio::net::TcpStream::from_std(stream)?;
+            let (conn, ldap) = match LdapConnAsync::from_tcp_stream(stream, settings, url).await {
+                Ok((conn, ldap)) => (conn, ldap),
+                Err(e) => return Err(e),
+            };
+            super::drive!(conn);
+            Ok(ldap)
+        })?;
+        Ok(LdapConn { ldap, rt })
+    }
+
     /// See [`Ldap::with_search_options()`](struct.Ldap.html#method.with_search_options).
     pub fn with_search_options(&mut self, opts: SearchOptions) -> &mut Self {
         self.ldap.search_opts = Some(opts);