use futures_core::future::BoxFuture;
use futures_core::stream::BoxStream;
use futures_util::{StreamExt, TryStreamExt};
use native_tls::Certificate;
use sqlx_core::connection::Connection;
use sqlx_core::decode::Decode;
use sqlx_core::error::Error;
use sqlx_core::executor::{Execute, Executor};
use sqlx_core::ext::async_stream::TryAsyncStream;
use sqlx_core::sql_str::SqlStr;
use sqlx_core::transaction::Transaction;
use sqlx_core::value::Value;
use sqlx_core::Either;
use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_native_tls::TlsConnector;
use crate::error::server_error;
use crate::protocol::login::build_login7_packet;
use crate::protocol::packet::{PacketHeader, PacketType, PACKET_HEADER_LEN};
use crate::protocol::pre_login::{build_pre_login_packet, parse_server_encrypt};
use crate::protocol::query::{build_sql_batch_packet, QueryEvent, QueryEvents};
use crate::protocol::rpc::{
build_execute_sql_packet, build_prepare_packet, build_unprepare_packet,
};
use crate::protocol::token::{parse_login_response, EnvChange, LoginResponse};
use crate::tls::TlsPreloginStream;
use crate::{
ssrp, Encrypt, Mssql, MssqlArguments, MssqlColumn, MssqlConnectOptions, MssqlQueryResult,
MssqlRow, MssqlStatement, MssqlTypeInfo,
};
#[derive(Debug)]
pub struct MssqlConnection {
stream: Option<MssqlWireStream>,
response: Option<QueryResponse>,
transaction_depth: usize,
transaction_descriptor: u64,
pending_rollback_sql: Option<&'static str>,
}
impl MssqlConnection {
pub async fn establish(options: &MssqlConnectOptions) -> Result<Self, Error> {
let mut stream = MssqlWireStream::connect(options).await?;
let pre_login = build_pre_login_packet(options).map_err(|error| {
Error::Protocol(format!(
"failed to build SQL Server PRELOGIN packet: {error}"
))
})?;
stream
.write_all(&pre_login)
.await
.map_err(|error| context_error("failed to send SQL Server PRELOGIN packet", error))?;
let pre_login_response = stream
.read_message()
.await
.map_err(|error| context_error("failed to read SQL Server PRELOGIN response", error))?;
let server_encrypt = parse_server_encrypt(&pre_login_response).map_err(|error| {
Error::Protocol(format!(
"failed to parse SQL Server PRELOGIN response: {error}"
))
})?;
let encrypted = negotiate_encryption(options.encrypt(), server_encrypt)?;
if encrypted {
stream.enable_tls(options).await?;
}
let login = build_login7_packet(options).map_err(|error| {
Error::Protocol(format!("failed to build SQL Server LOGIN7 packet: {error}"))
})?;
stream
.write_all(&login)
.await
.map_err(|error| context_error("failed to send SQL Server LOGIN7 packet", error))?;
let login_response = stream
.read_message()
.await
.map_err(|error| context_error("failed to read SQL Server LOGIN7 response", error))?;
match parse_login_response(&login_response).map_err(|error| {
Error::Protocol(format!(
"failed to parse SQL Server LOGIN7 response: {error}"
))
})? {
LoginResponse::Success { env_changes, .. } => {
let mut conn = Self {
stream: Some(stream),
response: None,
transaction_depth: 0,
transaction_descriptor: 0,
pending_rollback_sql: None,
};
conn.apply_env_changes(&env_changes);
Ok(conn)
}
LoginResponse::ServerError(error) => Err(server_error(error)),
}
}
fn apply_env_changes(&mut self, env_changes: &[EnvChange]) {
for change in env_changes {
self.apply_env_change(change);
}
}
fn apply_env_change(&mut self, env_change: &EnvChange) {
match env_change {
EnvChange::PacketSize(size) => {
if let Some(stream) = self.stream.as_mut() {
stream.packet_size = (*size).clamp(512, 32767) as usize;
}
}
EnvChange::BeginTransaction(descriptor) => {
self.transaction_descriptor = *descriptor;
}
EnvChange::CommitTransaction(_) | EnvChange::RollbackTransaction(_) => {
self.transaction_descriptor = 0;
}
_ => {}
}
}
pub const fn transaction_depth(&self) -> usize {
self.transaction_depth
}
pub fn begin(
&mut self,
) -> impl std::future::Future<Output = Result<Transaction<'_, Mssql>, Error>> + Send + '_ {
<Self as Connection>::begin(self)
}
pub(crate) fn increment_transaction_depth(&mut self) {
self.transaction_depth += 1;
}
pub(crate) fn decrement_transaction_depth(&mut self) {
self.transaction_depth = self.transaction_depth.saturating_sub(1);
}
pub(crate) fn clear_transaction_depth(&mut self) {
self.transaction_depth = 0;
}
pub(crate) async fn run_sql_batch(&mut self, sql: &str) -> Result<(), Error> {
self.flush().await?;
self.run_sql_batch_direct(sql).await
}
async fn run_sql_batch_direct(&mut self, sql: &str) -> Result<(), Error> {
let packet = build_sql_batch_packet(sql, self.packet_size()?, self.transaction_descriptor)
.map_err(frame_error)?;
self.start_response(&packet, "SQL batch").await?;
self.finish_response().await
}
pub(crate) fn queue_rollback(&mut self) {
let sql = match self.transaction_depth {
0 => return,
1 => {
self.transaction_depth = 0;
"ROLLBACK TRANSACTION"
}
_ => {
self.transaction_depth -= 1;
"ROLLBACK TRANSACTION sqlx_savepoint"
}
};
self.pending_rollback_sql = Some(sql);
}
async fn start_query(
&mut self,
sql: &str,
arguments: Option<&MssqlArguments>,
) -> Result<(), Error> {
self.flush().await?;
let packet_size = self.packet_size()?;
let transaction_descriptor = self.transaction_descriptor;
let (packet, operation) = match arguments {
Some(arguments) if !arguments.is_empty() => {
let packet =
build_execute_sql_packet(sql, arguments, packet_size, transaction_descriptor)
.map_err(|error| {
Error::Protocol(format!("failed to encode SQL Server RPC: {error}"))
})?;
(packet, "RPC execute")
}
_ => {
let packet = build_sql_batch_packet(sql, packet_size, transaction_descriptor)
.map_err(frame_error)?;
(packet, "SQL batch")
}
};
self.start_response(&packet, operation).await
}
pub(crate) async fn run_prepare(
&mut self,
sql: &str,
parameters: &[MssqlTypeInfo],
) -> Result<Vec<MssqlColumn>, Error> {
self.flush().await?;
let packet = build_prepare_packet(
sql,
parameters,
self.packet_size()?,
self.transaction_descriptor,
)
.map_err(|error| {
Error::Protocol(format!("failed to encode SQL Server prepare RPC: {error}"))
})?;
self.start_response(&packet, "prepare RPC").await?;
let mut columns = Vec::new();
let mut statement_id = None;
while let Some(event) = self.next_event().await? {
match event {
QueryEvent::Columns(metadata) => columns = metadata,
QueryEvent::ReturnValue(value) if statement_id.is_none() => {
statement_id = Some(<i32 as Decode<Mssql>>::decode(value.as_ref()).map_err(
|source| Error::ColumnDecode {
index: "return value".to_owned(),
source,
},
)?);
}
_ => {}
}
}
if let Some(statement_id) = statement_id {
let packet = build_unprepare_packet(
statement_id,
self.packet_size()?,
self.transaction_descriptor,
)
.map_err(|error| {
Error::Protocol(format!(
"failed to encode SQL Server unprepare RPC: {error}"
))
})?;
self.start_response(&packet, "unprepare RPC").await?;
self.finish_response().await?;
}
Ok(columns)
}
fn packet_size(&self) -> Result<usize, Error> {
self.stream
.as_ref()
.map(|stream| stream.packet_size)
.ok_or_else(stream_unavailable)
}
async fn start_response(
&mut self,
packet: &[u8],
operation: &'static str,
) -> Result<(), Error> {
let mut wire = self.stream.take().ok_or_else(stream_unavailable)?;
wire.write_all(packet).await.map_err(|error| {
context_error(
format!("failed to send SQL Server {operation} packet"),
error,
)
})?;
let mut response = QueryResponse {
operation,
events: QueryEvents::default(),
next_packet_id: None,
};
self.stream = Some(wire);
response.read_packet(&mut self.stream).await?;
self.response = Some(response);
Ok(())
}
async fn next_event(&mut self) -> Result<Option<QueryEvent>, Error> {
let Some(response) = &mut self.response else {
return Ok(None);
};
let event = response.next(&mut self.stream).await;
match &event {
Ok(Some(QueryEvent::EnvChange(change))) => self.apply_env_change(change),
Ok(None) => self.response = None,
Ok(Some(_)) | Err(Error::Database(_)) => {}
Err(_) => {
self.stream = None;
self.response = None;
}
}
event
}
async fn finish_response(&mut self) -> Result<(), Error> {
while self.next_event().await?.is_some() {}
Ok(())
}
pub(crate) fn fetch_many_sql<'e>(
&'e mut self,
sql: SqlStr,
arguments: Result<Option<MssqlArguments>, Error>,
) -> BoxStream<'e, Result<Either<MssqlQueryResult, MssqlRow>, Error>> {
TryAsyncStream::new(move |rows| async move {
self.start_query(sql.as_str(), arguments?.as_ref()).await?;
while let Some(event) = self.next_event().await? {
match event {
QueryEvent::Row(row) => rows.r#yield(Either::Right(row)).await,
QueryEvent::Result(result) => rows.r#yield(Either::Left(result)).await,
_ => {}
}
}
Ok(())
})
.boxed()
}
pub(crate) async fn fetch_optional_sql(
&mut self,
sql: SqlStr,
arguments: Result<Option<MssqlArguments>, Error>,
) -> Result<Option<MssqlRow>, Error> {
let mut stream = self.fetch_many_sql(sql, arguments);
let mut first_row = None;
while let Some(item) = stream.try_next().await? {
match item {
Either::Right(row) if first_row.is_none() => first_row = Some(row),
_ => {}
}
}
Ok(first_row)
}
}
impl Connection for MssqlConnection {
type Database = Mssql;
type Options = MssqlConnectOptions;
async fn close(mut self) -> Result<(), Error> {
if self.pending_rollback_sql.is_some() {
self.flush().await?;
}
if let Some(mut stream) = self.stream.take() {
stream.shutdown().await?;
}
Ok(())
}
async fn close_hard(mut self) -> Result<(), Error> {
if let Some(mut stream) = self.stream.take() {
stream.shutdown().await?;
}
Ok(())
}
async fn ping(&mut self) -> Result<(), Error> {
self.run_sql_batch("SELECT 1").await?;
Ok(())
}
fn begin(
&mut self,
) -> impl std::future::Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
{
Transaction::begin(self, None)
}
fn shrink_buffers(&mut self) {}
async fn flush(&mut self) -> Result<(), Error> {
loop {
match self.next_event().await {
Ok(None) => break,
Ok(Some(_)) | Err(Error::Database(_)) => {}
Err(error) => return Err(error),
}
}
if let Some(sql) = self.pending_rollback_sql.take() {
self.run_sql_batch_direct(sql).await?;
}
Ok(())
}
fn should_flush(&self) -> bool {
self.response.is_some() || self.pending_rollback_sql.is_some()
}
}
impl<'c> Executor<'c> for &'c mut MssqlConnection {
type Database = Mssql;
fn fetch_many<'e, 'q, E>(
self,
mut query: E,
) -> BoxStream<'e, Result<Either<MssqlQueryResult, MssqlRow>, Error>>
where
'c: 'e,
E: Execute<'q, Self::Database>,
'q: 'e,
E: 'q,
{
let arguments = query.take_arguments().map_err(Error::Encode);
let sql = query.sql();
self.fetch_many_sql(sql, arguments)
}
fn fetch_optional<'e, 'q, E>(
self,
mut query: E,
) -> BoxFuture<'e, Result<Option<MssqlRow>, Error>>
where
'c: 'e,
E: Execute<'q, Self::Database>,
'q: 'e,
E: 'q,
{
let arguments = query.take_arguments().map_err(Error::Encode);
Box::pin(self.fetch_optional_sql(query.sql(), arguments))
}
fn prepare_with<'e>(
self,
sql: sqlx_core::sql_str::SqlStr,
parameters: &'e [crate::MssqlTypeInfo],
) -> BoxFuture<'e, Result<MssqlStatement, Error>>
where
'c: 'e,
{
Box::pin(async move {
let columns = self.run_prepare(sql.as_str(), parameters).await?;
let parameters = if parameters.is_empty() {
None
} else {
Some(Either::Left(parameters.to_vec()))
};
Ok(MssqlStatement::with_parameters(sql, columns, parameters))
})
}
}
fn stream_unavailable() -> Error {
Error::Io(std::io::Error::new(
std::io::ErrorKind::NotConnected,
"SQL Server connection is closed",
))
}
struct MssqlWireStream {
stream: MssqlStream,
packet_size: usize,
}
impl std::fmt::Debug for MssqlWireStream {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MssqlWireStream")
.field("encrypted", &matches!(self.stream, MssqlStream::Tls(_)))
.field("packet_size", &self.packet_size)
.finish()
}
}
enum MssqlStream {
Raw(TcpStream),
Tls(tokio_native_tls::TlsStream<TlsPreloginStream<TcpStream>>),
Taken,
}
impl MssqlWireStream {
async fn connect(options: &MssqlConnectOptions) -> Result<Self, Error> {
let port = match (options.port(), options.instance()) {
(Some(port), _) => port,
(None, Some(instance)) => ssrp::resolve_instance_port(options.host(), instance).await?,
(None, None) => 1433,
};
let stream = TcpStream::connect((options.host(), port))
.await
.map_err(|error| {
Error::Io(std::io::Error::new(
error.kind(),
format!(
"failed to connect to SQL Server at {}:{port}{}: {error}",
options.host(),
options
.instance()
.map(|instance| format!(" (instance={instance})"))
.unwrap_or_default()
),
))
})?;
let packet_size = usize::try_from(options.requested_packet_size()).map_err(|_| {
Error::Protocol(format!(
"SQL Server packet size {} does not fit usize",
options.requested_packet_size()
))
})?;
Ok(Self {
stream: MssqlStream::Raw(stream),
packet_size,
})
}
async fn write_all(&mut self, bytes: &[u8]) -> Result<(), Error> {
match &mut self.stream {
MssqlStream::Raw(stream) => {
write_tds_packets(stream, bytes).await?;
}
MssqlStream::Tls(stream) => {
write_tds_packets(stream, bytes).await?;
}
MssqlStream::Taken => return Err(taken_stream_error()),
}
Ok(())
}
async fn shutdown(&mut self) -> Result<(), Error> {
match &mut self.stream {
MssqlStream::Raw(stream) => stream.shutdown().await?,
MssqlStream::Tls(stream) => stream.shutdown().await?,
MssqlStream::Taken => return Err(taken_stream_error()),
}
Ok(())
}
async fn enable_tls(&mut self, options: &MssqlConnectOptions) -> Result<(), Error> {
let stream = match std::mem::replace(&mut self.stream, MssqlStream::Taken) {
MssqlStream::Raw(stream) => stream,
other => {
self.stream = other;
return Ok(());
}
};
let mut stream = TlsPreloginStream::new(stream);
stream.start_handshake();
let domain = options
.hostname_in_certificate()
.unwrap_or_else(|| options.host());
let connector = build_tls_connector(options)?;
let mut stream = connector
.connect(domain, stream)
.await
.map_err(|error| {
Error::Tls(
std::io::Error::other(format!(
"SQL Server TLS handshake failed for host `{}` during the TDS PRELOGIN encryption upgrade \
(encrypt={:?}, trust_server_certificate={}, hostname_in_certificate={}, ssl_root_cert={}): {}",
domain,
options.encrypt(),
options.trust_server_certificate(),
options.hostname_in_certificate().unwrap_or("<not set>"),
options.ssl_root_cert().is_some(),
error
))
.into(),
)
})?;
stream.get_mut().get_mut().get_mut().finish_handshake();
self.stream = MssqlStream::Tls(stream);
Ok(())
}
async fn read_message(&mut self) -> Result<Vec<u8>, Error> {
let mut expected_id = None;
let mut message = Vec::new();
loop {
let (header, payload) = self.read_packet(expected_id).await?;
message.extend_from_slice(&payload);
expected_id = header.next_packet_id();
if expected_id.is_none() {
return Ok(message);
}
}
}
async fn read_packet(
&mut self,
expected_id: Option<u8>,
) -> Result<(PacketHeader, Vec<u8>), Error> {
let mut bytes = [0; PACKET_HEADER_LEN];
self.read_exact(&mut bytes).await?;
let header = PacketHeader::decode(&bytes).map_err(packet_error)?;
if header.packet_type != PacketType::TABULAR_RESULT {
return Err(Error::Protocol(format!(
"expected a SQL Server tabular result, got packet type 0x{:02x}",
header.packet_type.code()
)));
}
if let Some(expected) = expected_id {
if header.packet_id != expected {
return Err(Error::Protocol(format!(
"non-contiguous SQL Server packet id: expected {expected}, got {}",
header.packet_id
)));
}
}
let len = usize::from(header.length);
if len > self.packet_size {
return Err(Error::Protocol(format!(
"SQL Server packet length {len} exceeds negotiated packet size {}",
self.packet_size
)));
}
let mut payload = vec![0; len - PACKET_HEADER_LEN];
self.read_exact(&mut payload).await?;
Ok((header, payload))
}
async fn read_exact(&mut self, bytes: &mut [u8]) -> Result<(), Error> {
match &mut self.stream {
MssqlStream::Raw(stream) => {
stream.read_exact(bytes).await?;
}
MssqlStream::Tls(stream) => {
stream.read_exact(bytes).await?;
}
MssqlStream::Taken => return Err(taken_stream_error()),
}
Ok(())
}
}
async fn write_tds_packets<S>(stream: &mut S, bytes: &[u8]) -> Result<(), Error>
where
S: AsyncWrite + Unpin,
{
let mut offset = 0usize;
while offset < bytes.len() {
let packet = tds_packet_slice(bytes, offset)?;
stream.write_all(packet).await?;
offset += packet.len();
}
stream.flush().await?;
Ok(())
}
fn tds_packet_slice(bytes: &[u8], offset: usize) -> Result<&[u8], Error> {
let header_end = offset
.checked_add(PACKET_HEADER_LEN)
.ok_or_else(|| Error::Protocol("SQL Server outbound packet offset overflow".to_owned()))?;
let header_bytes = bytes.get(offset..header_end).ok_or_else(|| {
Error::Protocol("SQL Server outbound packet buffer ended inside a header".to_owned())
})?;
let header = PacketHeader::decode(header_bytes).map_err(packet_error)?;
let packet_len = usize::from(header.length);
let packet_end = offset
.checked_add(packet_len)
.ok_or_else(|| Error::Protocol("SQL Server outbound packet length overflow".to_owned()))?;
bytes.get(offset..packet_end).ok_or_else(|| {
Error::Protocol("SQL Server outbound packet buffer ended inside a packet".to_owned())
})
}
fn negotiate_encryption(requested: Encrypt, server: Encrypt) -> std::result::Result<bool, Error> {
match (requested, server) {
(Encrypt::NotSupported, Encrypt::NotSupported | Encrypt::Off) => Ok(false),
(Encrypt::NotSupported, Encrypt::On | Encrypt::Required) => Err(Error::Protocol(
"SQL Server requires encryption, but the client URL requested encrypt=not_supported"
.to_owned(),
)),
(Encrypt::Required, Encrypt::Off | Encrypt::NotSupported) => Err(Error::Tls(
"SQL Server TLS encryption is required but not supported by the server".into(),
)),
(Encrypt::On | Encrypt::Required, Encrypt::On | Encrypt::Required) => Ok(true),
(Encrypt::Off, _) | (_, Encrypt::Off) => Err(Error::Protocol(
"SQL Server login-only TLS fallback is not implemented yet; use encrypt=mandatory or encrypt=strict for encrypted connections, or encrypt=not_supported for plaintext development servers"
.to_owned(),
)),
(Encrypt::On, Encrypt::NotSupported) => Ok(false),
}
}
fn build_tls_connector(options: &MssqlConnectOptions) -> Result<TlsConnector, Error> {
let mut builder = native_tls::TlsConnector::builder();
builder.danger_accept_invalid_certs(options.trust_server_certificate());
builder.danger_accept_invalid_hostnames(options.hostname_in_certificate().is_none());
if let Some(path) = options.ssl_root_cert() {
let cert = std::fs::read(path).map_err(|error| {
Error::Io(std::io::Error::new(
error.kind(),
format!(
"failed to read SQL Server ssl_root_cert `{}`: {error}",
path.display()
),
))
})?;
let cert = Certificate::from_pem(&cert)
.or_else(|_| Certificate::from_der(&cert))
.map_err(|error| {
Error::Tls(
format!(
"failed to parse SQL Server ssl_root_cert `{}` as PEM or DER: {error}",
path.display()
)
.into(),
)
})?;
builder.add_root_certificate(cert);
}
builder.build().map(TlsConnector::from).map_err(|error| {
Error::Tls(format!("failed to build SQL Server TLS connector: {error}").into())
})
}
fn taken_stream_error() -> Error {
Error::Protocol("SQL Server stream was used while TLS upgrade was in progress".to_owned())
}
fn packet_error(error: crate::protocol::packet::PacketHeaderError) -> Error {
Error::Protocol(error.to_string())
}
fn frame_error(error: crate::protocol::packet::PacketFrameError) -> Error {
Error::Protocol(error.to_string())
}
fn context_error(context: impl Into<String>, error: Error) -> Error {
let context = context.into();
match error {
Error::Io(error) => Error::Io(std::io::Error::new(
error.kind(),
format!("{context}: {error}"),
)),
Error::Tls(error) => Error::Tls(format!("{context}: {error}").into()),
Error::Protocol(message) => Error::Protocol(format!("{context}: {message}")),
error => Error::Protocol(format!("{context}: {error}")),
}
}
#[derive(Debug)]
struct QueryResponse {
operation: &'static str,
events: QueryEvents,
next_packet_id: Option<u8>,
}
impl QueryResponse {
async fn read_packet(&mut self, socket: &mut Option<MssqlWireStream>) -> Result<(), Error> {
let mut wire = socket.take().ok_or_else(stream_unavailable)?;
let (header, payload) = wire
.read_packet(self.next_packet_id)
.await
.map_err(|error| {
context_error(
format!("failed to read SQL Server {} response", self.operation),
error,
)
})?;
*socket = Some(wire);
self.events.push_packet(payload.into());
self.next_packet_id = header.next_packet_id();
Ok(())
}
async fn next(
&mut self,
wire: &mut Option<MssqlWireStream>,
) -> Result<Option<QueryEvent>, Error> {
loop {
if let Some(event) = self.events.next()? {
return Ok(Some(event));
}
if self.next_packet_id.is_none() {
self.events.finish()?;
return Ok(None);
}
self.read_packet(wire).await?;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn negotiates_full_tls_for_required_or_mandatory_encryption() {
assert!(negotiate_encryption(Encrypt::On, Encrypt::On).unwrap());
assert!(negotiate_encryption(Encrypt::Required, Encrypt::Required).unwrap());
}
#[test]
fn allows_plaintext_only_when_explicitly_requested_and_supported() {
assert!(!negotiate_encryption(Encrypt::NotSupported, Encrypt::Off).unwrap());
assert!(negotiate_encryption(Encrypt::NotSupported, Encrypt::Required).is_err());
}
#[test]
fn rejects_login_only_tls_fallback_until_downgrade_is_available() {
assert!(negotiate_encryption(Encrypt::Off, Encrypt::On).is_err());
assert!(negotiate_encryption(Encrypt::On, Encrypt::Off).is_err());
}
#[test]
fn slices_encoded_outbound_packets_by_header_length() {
let bytes = crate::protocol::packet::encode_message(PacketType::RPC, &[0; 11], 12).unwrap();
let first = tds_packet_slice(&bytes, 0).unwrap();
assert_eq!(12, first.len());
let second = tds_packet_slice(&bytes, first.len()).unwrap();
assert_eq!(12, second.len());
let third = tds_packet_slice(&bytes, first.len() + second.len()).unwrap();
assert_eq!(11, third.len());
}
#[test]
fn rejects_truncated_outbound_packet() {
let bytes = crate::protocol::packet::encode_message(PacketType::RPC, &[0; 11], 12).unwrap();
let err = tds_packet_slice(&bytes[..bytes.len() - 1], 24).unwrap_err();
assert!(err.to_string().contains("ended inside a packet"));
}
#[tokio::test]
async fn ping_rejects_a_socket_closed_by_the_server() {
let (mut conn, server) = loopback_connection().await;
drop(server);
assert!(matches!(conn.ping().await, Err(Error::Io(_))));
assert!(conn.stream.is_none());
}
#[tokio::test]
async fn dropping_a_query_while_awaiting_a_reply_closes_the_socket() {
let (mut conn, mut server) = loopback_connection().await;
let mut query = Box::pin(conn.run_sql_batch("SELECT 1"));
let mut header = [0; PACKET_HEADER_LEN];
tokio::select! {
result = &mut query => panic!("query finished before the server sent a reply: {result:?}"),
result = server.read_exact(&mut header) => { result.unwrap(); }
}
assert_eq!(
PacketHeader::decode(&header).unwrap().packet_type,
PacketType::SQL_BATCH
);
drop(query);
assert!(matches!(
conn.ping().await,
Err(Error::Io(error)) if error.kind() == std::io::ErrorKind::NotConnected
));
}
async fn loopback_connection() -> (MssqlConnection, TcpStream) {
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
.await
.unwrap();
let addr = listener.local_addr().unwrap();
let (client, server) = tokio::join!(TcpStream::connect(addr), listener.accept());
let conn = MssqlConnection {
stream: Some(MssqlWireStream {
stream: MssqlStream::Raw(client.unwrap()),
packet_size: 4096,
}),
response: None,
transaction_depth: 0,
transaction_descriptor: 0,
pending_rollback_sql: None,
};
(conn, server.unwrap().0)
}
}