aboutsummaryrefslogblamecommitdiff
path: root/aero-proto/src/imap/command/anonymous.rs
blob: f23ec17688930cbe68c54ba89815f245a7f0fb8f (plain) (tree)
1
2
3
4
5
6
7
8
9
                   
                                                            
                                          
                                           
                                           
 
                                 
                                       
 
                                              
                                   
                      
                                    


                 
                                 
                                  
                                                  
                                             

 
                                                                                                   
                         

                                                                         


                                                                              
                                                  

                                                     
                                                                                         

                                                                          
         



                                                                            


     
                                  
 
                               

                   

                                       
                                                        
                      

                                                                 

                                                   
 
                                                                   


                                                                   
                                     

                                                         
                               




                                           
 
                                                          


                                                 
                             
                                 
                                                                          
                                     
                       


                                                 
 
use anyhow::Result;
use imap_codec::imap_types::command::{Command, CommandBody};
use imap_codec::imap_types::core::AString;
use imap_codec::imap_types::response::Code;
use imap_codec::imap_types::secret::Secret;

use aero_collections::user::User;
use aero_user::login::ArcLoginProvider;

use crate::imap::capability::ServerCapability;
use crate::imap::command::anystate;
use crate::imap::flow;
use crate::imap::response::Response;

//--- dispatching

pub struct AnonymousContext<'a> {
    pub req: &'a Command<'static>,
    pub server_capabilities: &'a ServerCapability,
    pub login_provider: &'a ArcLoginProvider,
}

pub async fn dispatch(ctx: AnonymousContext<'_>) -> Result<(Response<'static>, flow::Transition)> {
    match &ctx.req.body {
        // Any State
        CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
        CommandBody::Capability => {
            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
        }
        CommandBody::Logout => anystate::logout(),

        // Specific to anonymous context (3 commands)
        CommandBody::Login { username, password } => ctx.login(username, password).await,
        CommandBody::Authenticate { .. } => {
            anystate::not_implemented(ctx.req.tag.clone(), "authenticate")
        }
        //StartTLS is not implemented for now, we will probably go full TLS.

        // Collect other commands
        _ => anystate::wrong_state(ctx.req.tag.clone()),
    }
}

//--- Command controllers, private

impl<'a> AnonymousContext<'a> {
    async fn login(
        self,
        username: &AString<'a>,
        password: &Secret<AString<'a>>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let (u, p) = (
            std::str::from_utf8(username.as_ref())?,
            std::str::from_utf8(password.declassify().as_ref())?,
        );
        tracing::info!(user = %u, "command.login");

        let creds = match self.login_provider.login(&u, &p).await {
            Err(e) => {
                tracing::debug!(error=%e, "authentication failed");
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("Authentication failed")
                        .no()?,
                    flow::Transition::None,
                ));
            }
            Ok(c) => c,
        };

        let user = User::new(u.to_string(), creds).await?;

        tracing::info!(username=%u, "connected");
        Ok((
            Response::build()
                .to_req(self.req)
                .code(Code::Capability(self.server_capabilities.to_vec()))
                .message("Completed")
                .ok()?,
            flow::Transition::Authenticate(user),
        ))
    }
}