wtx 0.43.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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

use crate::{
  codec::Encode,
  collection::ArrayVectorU8,
  database::client::mysql::{
    auth_plugin::AuthPlugin,
    capability::Capability,
    collation::Collation,
    misc::encoded_len,
    protocol::{Protocol, encode_wrapper_protocol::EncodeWrapperProtocol, initial_req::InitialReq},
  },
};

pub(crate) struct HandshakeReq<'bytes> {
  pub(crate) auth_plugin: Option<AuthPlugin>,
  pub(crate) auth_response: Option<ArrayVectorU8<u8, 32>>,
  pub(crate) collation: Collation,
  pub(crate) database: Option<&'bytes str>,
  pub(crate) max_packet_size: u32,
  pub(crate) username: &'bytes str,
}

impl<E> Encode<Protocol<(), E>> for HandshakeReq<'_>
where
  E: From<crate::Error>,
{
  #[inline]
  fn encode(&self, ew: &mut EncodeWrapperProtocol<'_>) -> Result<(), E> {
    if self.auth_plugin.is_none() {
      *ew.capabilities &= !u64::from(Capability::PluginAuth);
    }

    let req = InitialReq { collation: self.collation, max_packet_size: self.max_packet_size };
    req.encode(ew)?;
    let _ = ew.encode_buffer.extend_from_copyable_slices([self.username.as_bytes(), b"\0"])?;

    let connect_n = u64::from(Capability::ConnectWithDb);
    let plugin_auth = u64::from(Capability::PluginAuth);
    let plugin_auth_lenenc_n = u64::from(Capability::PluginAuthLenencData);
    let secure_n = u64::from(Capability::SecureConnection);

    if *ew.capabilities & plugin_auth_lenenc_n == plugin_auth_lenenc_n {
      let auth_response = self.auth_response.as_deref().unwrap_or_default();
      let array = [&encoded_len(auth_response.len())?, auth_response];
      let _ = ew.encode_buffer.extend_from_copyable_slices(array)?;
    } else if *ew.capabilities & secure_n == secure_n {
      let auth_response = self.auth_response.as_deref().unwrap_or_default();
      let len = u8::try_from(auth_response.len()).map_err(crate::Error::from)?;
      let _ = ew.encode_buffer.extend_from_copyable_slices([&[len][..], auth_response])?;
    } else {
      ew.encode_buffer.extend_from_copyable_slice("\0".as_bytes())?;
    }

    if *ew.capabilities & connect_n == connect_n {
      if let Some(database) = self.database {
        let _ = ew.encode_buffer.extend_from_copyable_slices([database.as_bytes(), b"\0"])?;
      } else {
        ew.encode_buffer.extend_from_copyable_slice("\0".as_bytes())?;
      }
    }

    if *ew.capabilities & plugin_auth == plugin_auth {
      if let Some(auth_plugin) = self.auth_plugin {
        let array = [<&str>::from(auth_plugin).as_bytes(), b"\0"];
        let _ = ew.encode_buffer.extend_from_copyable_slices(array)?;
      } else {
        ew.encode_buffer.extend_from_copyable_slice("\0".as_bytes())?;
      }
    }

    Ok(())
  }
}