orcinus 0.3.0

async-ready mysql protocol implementation / wrapper libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

mod clear_text;
mod secure_password;
mod sha256;

use std::io::Read;
use std::io::Write;

use crate::protos::CapabilityFlags;
use crate::protos::ClientPacket;
use crate::protos::HandshakeResponse320;
use crate::protos::HandshakeResponse41;
use crate::protos::OKPacket;
use crate::CommunicationError;

pub use self::clear_text::*;
pub use self::secure_password::*;
pub use self::sha256::*;

/// Detailed connection information to perform Authentication flow
pub struct ConnectionInfo<'s> {
    pub client_capabilities: CapabilityFlags,
    pub max_packet_size: u32,
    pub character_set: u8,
    pub username: &'s str,
    pub password: &'s str,
    pub database: Option<&'s str>,
}
impl ConnectionInfo<'_> {
    /// Make a handshake response with authentication responses
    #[inline]
    pub fn make_handshake_response<'s>(
        &'s self,
        auth_response: &'s [u8],
        auth_plugin_name: Option<&'s str>,
    ) -> Box<dyn ClientPacket + Sync + Send + 's> {
        if self.client_capabilities.support_41_protocol() {
            Box::new(HandshakeResponse41 {
                capability: self.client_capabilities,
                max_packet_size: self.max_packet_size,
                character_set: self.character_set,
                username: self.username,
                auth_response,
                database: self.database,
                auth_plugin_name,
                connect_attrs: Default::default(),
            })
        } else {
            Box::new(HandshakeResponse320 {
                capability: self.client_capabilities,
                max_packet_size: self.max_packet_size,
                username: self.username,
                auth_response,
                database: self.database,
            })
        }
    }
}

/// An Authentication Plugin implementation
pub trait Authentication {
    /// Authentication Plugin name
    const NAME: &'static str;

    /// Run Authentication flow
    fn run_sync(
        &self,
        stream: impl Read + Write,
        con_info: &ConnectionInfo,
        first_sequence_id: u8,
    ) -> Result<(OKPacket, u8), CommunicationError>;
}
/// Asynchronous implementation of Authentication flow
pub trait AsyncAuthentication<'s, S: 's + Send>: Authentication {
    /// Future type of Authentication flow
    type OperationF: std::future::Future<Output = Result<(OKPacket, u8), CommunicationError>> + Send + 's;

    /// Run Authentication flow
    fn run(&'s self, stream: S, con_info: &'s ConnectionInfo, first_sequence_id: u8) -> Self::OperationF;
}