implement starttls

1 files changed, 42 insertions, 43 deletions

diff --git a/src/jabber.rs b/src/jabber.rs
index afe840b..87a2b44 100644
--- a/src/jabber.rs
+++ b/src/jabber.rs
@@ -1,14 +1,18 @@
 use std::str;
 use std::sync::Arc;
 
+use peanuts::element::{FromElement, IntoElement};
 use peanuts::{Reader, Writer};
 use rsasl::prelude::SASLConfig;
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
+use tokio_native_tls::native_tls::TlsConnector;
 use tracing::{debug, info, trace};
+use trust_dns_resolver::proto::rr::domain::IntoLabel;
 
 use crate::connection::{Tls, Unencrypted};
 use crate::error::Error;
-use crate::stanza::stream::Stream;
+use crate::stanza::starttls::{Proceed, StartTls};
+use crate::stanza::stream::{Features, Stream};
 use crate::stanza::XML_VERSION;
 use crate::Result;
 use crate::JID;
@@ -62,7 +66,6 @@ where
         // opening stream element
         let server = self.server.clone().try_into()?;
         let stream = Stream::new_client(None, server, None, "en".to_string());
-        // TODO: nicer function to serialize to xml writer
         self.writer.write_start(&stream).await?;
 
         // server to client
@@ -72,57 +75,53 @@ where
 
         // receive stream element and validate
         let stream: Stream = self.reader.read_start().await?;
+        debug!("got stream: {:?}", stream);
         if let Some(from) = stream.from {
             self.server = from.to_string()
         }
 
         Ok(())
     }
-}
 
-// pub async fn get_features(&mut self) -> Result<Vec<StreamFeature>> {
-//     Element::read(&mut self.reader).await?.try_into()
-// }
+    pub async fn get_features(&mut self) -> Result<Features> {
+        debug!("getting features");
+        let features: Features = self.reader.read().await?;
+        debug!("got features: {:?}", features);
+        Ok(features)
+    }
+
+    pub fn into_inner(self) -> S {
+        self.reader.into_inner().unsplit(self.writer.into_inner())
+    }
+}
 
 impl Jabber<Unencrypted> {
-    pub async fn starttls(&mut self) -> Result<Jabber<Tls>> {
-        todo!()
+    pub async fn starttls(mut self) -> Result<Jabber<Tls>> {
+        self.writer
+            .write_full(&StartTls { required: false })
+            .await?;
+        let proceed: Proceed = self.reader.read().await?;
+        debug!("got proceed: {:?}", proceed);
+        let connector = TlsConnector::new().unwrap();
+        let stream = self.reader.into_inner().unsplit(self.writer.into_inner());
+        if let Ok(tlsstream) = tokio_native_tls::TlsConnector::from(connector)
+            .connect(&self.server, stream)
+            .await
+        {
+            let (read, write) = tokio::io::split(tlsstream);
+            let mut client = Jabber::new(
+                read,
+                write,
+                self.jid.to_owned(),
+                self.auth.to_owned(),
+                self.server.to_owned(),
+            );
+            client.start_stream().await?;
+            return Ok(client);
+        } else {
+            return Err(Error::Connection);
+        }
     }
-    //     let mut starttls_element = BytesStart::new("starttls");
-    //     starttls_element.push_attribute(("xmlns", "urn:ietf:params:xml:ns:xmpp-tls"));
-    //     self.writer
-    //         .write_event_async(Event::Empty(starttls_element))
-    //         .await
-    //         .unwrap();
-    //     let mut buf = Vec::new();
-    //     match self.reader.read_event_into_async(&mut buf).await.unwrap() {
-    //         Event::Empty(e) => match e.name() {
-    //             QName(b"proceed") => {
-    //                 let connector = TlsConnector::new().unwrap();
-    //                 let stream = self
-    //                     .reader
-    //                     .into_inner()
-    //                     .into_inner()
-    //                     .unsplit(self.writer.into_inner());
-    //                 if let Ok(tlsstream) = tokio_native_tls::TlsConnector::from(connector)
-    //                     .connect(&self.jabber.server, stream)
-    //                     .await
-    //                 {
-    //                     let (read, write) = tokio::io::split(tlsstream);
-    //                     let reader = Reader::from_reader(BufReader::new(read));
-    //                     let writer = Writer::new(write);
-    //                     let mut client =
-    //                         super::encrypted::JabberClient::new(reader, writer, self.jabber);
-    //                     client.start_stream().await?;
-    //                     return Ok(client);
-    //                 }
-    //             }
-    //             QName(_) => return Err(JabberError::TlsNegotiation),
-    //         },
-    //         _ => return Err(JabberError::TlsNegotiation),
-    //     }
-    //     Err(JabberError::TlsNegotiation)
-    // }
 }
 
 impl std::fmt::Debug for Jabber<Tls> {