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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
use crate::common::StatementCache;
use crate::error::Error;
use crate::io::Decode;
use crate::mssql::connection::stream::MssqlStream;
use crate::mssql::protocol::login::Login7;
use crate::mssql::protocol::message::Message;
use crate::mssql::protocol::packet::PacketType;
use crate::mssql::protocol::pre_login::{Encrypt, PreLogin, Version};
use crate::mssql::{MssqlConnectOptions, MssqlConnection};
impl MssqlConnection {
pub(crate) async fn establish(options: &MssqlConnectOptions) -> Result<Self, Error> {
let mut stream: MssqlStream = MssqlStream::connect(options).await?;
// Send PRELOGIN to set up the context for login. The server should immediately
// respond with a PRELOGIN message of its own.
// TODO: Encryption
// TODO: Send the version of SQLx over
log::debug!(
"Sending T-SQL PRELOGIN with encryption: {:?}",
options.encrypt
);
stream
.write_packet_and_flush(
PacketType::PreLogin,
PreLogin {
version: Version::default(),
encryption: options.encrypt,
instance: options.instance.clone(),
..Default::default()
},
)
.await?;
let (_, packet) = stream.recv_packet().await?;
let prelogin_response = PreLogin::decode(packet)?;
if matches!(
prelogin_response.encryption,
Encrypt::Required | Encrypt::On
) {
stream.setup_encryption().await?;
} else if options.encrypt == Encrypt::Required {
return Err(Error::Tls(Box::new(std::io::Error::new(
std::io::ErrorKind::Other,
"TLS encryption required but not supported by server",
))));
}
// LOGIN7 defines the authentication rules for use between client and server
stream
.write_packet_and_flush(
PacketType::Tds7Login,
Login7 {
// FIXME: use a version constant
version: 0x74000004, // SQL Server 2012 - SQL Server 2019
client_program_version: options.client_program_version,
client_pid: options.client_pid,
packet_size: options.requested_packet_size, // max allowed size of TDS packet
hostname: &options.hostname,
username: &options.username,
password: options.password.as_deref().unwrap_or_default(),
app_name: &options.app_name,
server_name: &options.server_name,
client_interface_name: &options.client_interface_name,
language: &options.language,
database: &*options.database,
client_id: [0; 6],
},
)
.await?;
loop {
// NOTE: we should receive an [Error] message if something goes wrong, otherwise,
// all messages are mostly informational (ENVCHANGE, INFO, LOGINACK)
match stream.recv_message().await? {
Message::LoginAck(_) => {
// indicates that the login was successful
// no action is needed, we are just going to keep waiting till we hit <Done>
}
Message::Done(_) => {
break;
}
_ => {}
}
}
// FIXME: Do we need to expose the capacity count here? It's not tied to
// server-side resources but just .prepare() calls which return
// client-side data.
Ok(Self {
stream,
cache_statement: StatementCache::new(1024),
log_settings: options.log_settings.clone(),
})
}
}