Move auth-required message handling to bob module

This has an important behavioural change: error reporting to the user
will now happen in the group chat rather than in the possibly still
hidden 1:1 chat with alice.

Author: flub

src/securejoin.rs

@@ -34,19 +34,6 @@ use qrinvite::QrInvite;
 
 pub const NON_ALPHANUMERIC_WITHOUT_DOT: &AsciiSet = &NON_ALPHANUMERIC.remove(b'.');
 
-macro_rules! joiner_progress {
-    ($context:tt, $contact_id:expr, $progress:expr) => {
-        assert!(
-            $progress >= 0 && $progress <= 1000,
-            "value in range 0..1000 expected with: 0=error, 1..999=progress, 1000=success"
-        );
-        $context.emit_event($crate::events::EventType::SecurejoinJoinerProgress {
-            contact_id: $contact_id,
-            progress: $progress,
-        });
-    };
-}
-
 macro_rules! inviter_progress {
     ($context:tt, $contact_id:expr, $progress:expr) => {
         assert!(
@@ -384,32 +371,7 @@ pub(crate) async fn handle_securejoin_handshake(
             ====             Bob - the joiner's side             =====
             ====   Step 4 in "Setup verified contact" protocol   =====
             ========================================================*/
-            match BobState::from_db(&context.sql).await? {
-                Some(mut bobstate) => match bobstate.handle_message(context, mime_message).await? {
-                    Some(BobHandshakeStage::Terminated(why)) => {
-                        could_not_establish_secure_connection(
-                            context,
-                            contact_id,
-                            bobstate.alice_chat(),
-                            why,
-                        )
-                        .await?;
-                        Ok(HandshakeMessage::Done)
-                    }
-                    Some(_stage) => {
-                        if join_vg {
-                            // the message reads "Alice replied, waiting for being added to the group…";
-                            // show it only on secure-join and not on setup-contact therefore.
-                            let msg = stock_str::secure_join_replies(context, contact_id).await;
-                            chat::add_info_msg(context, bobstate.alice_chat(), msg, time()).await?;
-                        }
-                        joiner_progress!(context, bobstate.invite().contact_id(), 400);
-                        Ok(HandshakeMessage::Done)
-                    }
-                    None => Ok(HandshakeMessage::Ignore),
-                },
-                None => Ok(HandshakeMessage::Ignore),
-            }
+            bob::handle_auth_required(context, mime_message).await
         }
         "vg-request-with-auth" | "vc-request-with-auth" => {
             /*==========================================================

src/securejoin/bob.rs

@@ -11,11 +11,12 @@ use crate::contact::Contact;
 use crate::context::Context;
 use crate::dc_tools::time;
 use crate::events::EventType;
+use crate::mimeparser::MimeMessage;
 use crate::{chat, stock_str};
 
 use super::bobstate::{BobHandshakeStage, BobState};
 use super::qrinvite::QrInvite;
-use super::JoinError;
+use super::{HandshakeMessage, JoinError};
 
 /// Starts the securejoin protocol with the QR `invite`.
 ///
@@ -29,7 +30,10 @@ use super::JoinError;
 ///
 /// The [`ChatId`] of the created chat is returned, for a SetupContact QR this is the 1:1
 /// chat with Alice, for a SecureJoin QR this is the group chat.
-pub async fn start_protocol(context: &Context, invite: QrInvite) -> Result<ChatId, JoinError> {
+pub(super) async fn start_protocol(
+    context: &Context,
+    invite: QrInvite,
+) -> Result<ChatId, JoinError> {
     // A 1:1 chat is needed to send messages to Alice.  When joining a group this chat is
     // hidden, if a user starts sending messages in it it will be unhidden in
     // dc_receive_imf.
@@ -46,7 +50,7 @@ pub async fn start_protocol(context: &Context, invite: QrInvite) -> Result<ChatI
         BobState::start_protocol(context, invite.clone(), chat_id).await?;
     for state in aborted_states {
         error!(context, "Aborting previously unfinished QR Join process.");
-        state.notify_aborted(context).await?;
+        state.notify_aborted(context, "new QR scanned").await?;
         state.emit_progress(context, JoinerProgress::Error);
     }
     if matches!(stage, BobHandshakeStage::RequestWithAuthSent) {
@@ -74,8 +78,47 @@ pub async fn start_protocol(context: &Context, invite: QrInvite) -> Result<ChatI
     }
 }
 
+/// Handles `vc-auth-required` and `vg-auth-required` handshake messages.
+///
+/// # Bob - the joiner's side
+/// ## Step 4 in the "Setup Contact protocol"
+pub(super) async fn handle_auth_required(
+    context: &Context,
+    message: &MimeMessage,
+) -> Result<HandshakeMessage> {
+    match BobState::from_db(&context.sql).await? {
+        Some(mut bobstate) => match bobstate.handle_message(context, message).await? {
+            Some(BobHandshakeStage::Terminated(why)) => {
+                bobstate.notify_aborted(context, why).await?;
+                Ok(HandshakeMessage::Done)
+            }
+            Some(_stage) => {
+                if bobstate.is_join_group() {
+                    // The message reads "Alice replied, waiting to be added to the group…",
+                    // so only show it on secure-join and not on setup-contact.
+                    let contact_id = bobstate.invite().contact_id();
+                    let msg = stock_str::secure_join_replies(context, contact_id).await;
+                    let chat_id = bobstate.joining_chat_id(context).await?;
+                    chat::add_info_msg(context, chat_id, msg, time()).await?;
+                }
+                bobstate.emit_progress(context, JoinerProgress::RequestWithAuthSent);
+                Ok(HandshakeMessage::Done)
+            }
+            None => Ok(HandshakeMessage::Ignore),
+        },
+        None => Ok(HandshakeMessage::Ignore),
+    }
+}
+
 /// Private implementations for user interactions about this [`BobState`].
 impl BobState {
+    fn is_join_group(&self) -> bool {
+        match self.invite() {
+            QrInvite::Contact { .. } => false,
+            QrInvite::Group { .. } => true,
+        }
+    }
+
     fn emit_progress(&self, context: &Context, progress: JoinerProgress) {
         let contact_id = self.invite().contact_id();
         context.emit_event(EventType::SecurejoinJoinerProgress {
@@ -122,15 +165,21 @@ impl BobState {
         }
     }
 
-    async fn notify_aborted(&self, context: &Context) -> Result<()> {
+    /// Notifies the user that the SecureJoin was aborted.
+    ///
+    /// This creates and info message in the chat being joined.
+    async fn notify_aborted(&self, context: &Context, why: &str) -> Result<()> {
         let contact_addr = match Contact::get_by_id(context, self.invite().contact_id()).await {
             Ok(ref contact) => contact.get_addr().to_string(),
             Err(_) => "?".to_string(),
         };
-        // TODO: custom stock string?
         let msg = stock_str::contact_not_verified(context, contact_addr).await;
         let chat_id = self.joining_chat_id(context).await?;
         chat::add_info_msg(context, chat_id, &msg, time()).await?;
+        warn!(
+            context,
+            "StockMessage::ContactNotVerified posted to joining chat ({})", why
+        );
         Ok(())
     }
 }