1use futures_core::future::BoxFuture;
2use futures_core::stream::BoxStream;
3use futures_util::{StreamExt, TryStreamExt};
4use native_tls::Certificate;
5use sqlx_core::connection::Connection;
6use sqlx_core::decode::Decode;
7use sqlx_core::error::Error;
8use sqlx_core::executor::{Execute, Executor};
9use sqlx_core::ext::async_stream::TryAsyncStream;
10use sqlx_core::sql_str::SqlStr;
11use sqlx_core::transaction::Transaction;
12use sqlx_core::value::Value;
13use sqlx_core::Either;
14use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
15use tokio::net::TcpStream;
16use tokio_native_tls::TlsConnector;
17
18use crate::error::server_error;
19use crate::protocol::login::build_login7_packet;
20use crate::protocol::packet::{PacketHeader, PacketType, PACKET_HEADER_LEN};
21use crate::protocol::pre_login::{build_pre_login_packet, parse_server_encrypt};
22use crate::protocol::query::{build_sql_batch_packet, QueryEvent, QueryEvents};
23use crate::protocol::rpc::{
24 build_execute_sql_packet, build_prepare_packet, build_unprepare_packet,
25};
26use crate::protocol::token::{parse_login_response, EnvChange, LoginResponse};
27use crate::tls::TlsPreloginStream;
28use crate::{
29 ssrp, Encrypt, Mssql, MssqlArguments, MssqlColumn, MssqlConnectOptions, MssqlQueryResult,
30 MssqlRow, MssqlStatement, MssqlTypeInfo,
31};
32
33#[derive(Debug)]
35pub struct MssqlConnection {
36 stream: Option<MssqlWireStream>,
37 response: Option<QueryResponse>,
38 transaction_depth: usize,
39 transaction_descriptor: u64,
40 pending_rollback_sql: Option<&'static str>,
41}
42
43impl MssqlConnection {
44 pub async fn establish(options: &MssqlConnectOptions) -> Result<Self, Error> {
46 let mut stream = MssqlWireStream::connect(options).await?;
47
48 let pre_login = build_pre_login_packet(options).map_err(|error| {
49 Error::Protocol(format!(
50 "failed to build SQL Server PRELOGIN packet: {error}"
51 ))
52 })?;
53 stream
54 .write_all(&pre_login)
55 .await
56 .map_err(|error| context_error("failed to send SQL Server PRELOGIN packet", error))?;
57
58 let pre_login_response = stream
59 .read_message()
60 .await
61 .map_err(|error| context_error("failed to read SQL Server PRELOGIN response", error))?;
62
63 let server_encrypt = parse_server_encrypt(&pre_login_response).map_err(|error| {
64 Error::Protocol(format!(
65 "failed to parse SQL Server PRELOGIN response: {error}"
66 ))
67 })?;
68 let encrypted = negotiate_encryption(options.encrypt(), server_encrypt)?;
69
70 if encrypted {
71 stream.enable_tls(options).await?;
72 }
73
74 let login = build_login7_packet(options).map_err(|error| {
75 Error::Protocol(format!("failed to build SQL Server LOGIN7 packet: {error}"))
76 })?;
77 stream
78 .write_all(&login)
79 .await
80 .map_err(|error| context_error("failed to send SQL Server LOGIN7 packet", error))?;
81
82 let login_response = stream
83 .read_message()
84 .await
85 .map_err(|error| context_error("failed to read SQL Server LOGIN7 response", error))?;
86
87 match parse_login_response(&login_response).map_err(|error| {
88 Error::Protocol(format!(
89 "failed to parse SQL Server LOGIN7 response: {error}"
90 ))
91 })? {
92 LoginResponse::Success { env_changes, .. } => {
93 let mut conn = Self {
94 stream: Some(stream),
95 response: None,
96 transaction_depth: 0,
97 transaction_descriptor: 0,
98 pending_rollback_sql: None,
99 };
100 conn.apply_env_changes(&env_changes);
101 Ok(conn)
102 }
103 LoginResponse::ServerError(error) => Err(server_error(error)),
104 }
105 }
106
107 fn apply_env_changes(&mut self, env_changes: &[EnvChange]) {
108 for change in env_changes {
109 self.apply_env_change(change);
110 }
111 }
112
113 fn apply_env_change(&mut self, env_change: &EnvChange) {
114 match env_change {
115 EnvChange::PacketSize(size) => {
116 if let Some(stream) = self.stream.as_mut() {
117 stream.packet_size = (*size).clamp(512, 32767) as usize;
118 }
119 }
120 EnvChange::BeginTransaction(descriptor) => {
121 self.transaction_descriptor = *descriptor;
122 }
123 EnvChange::CommitTransaction(_) | EnvChange::RollbackTransaction(_) => {
124 self.transaction_descriptor = 0;
125 }
126 _ => {}
127 }
128 }
129
130 pub const fn transaction_depth(&self) -> usize {
132 self.transaction_depth
133 }
134
135 pub fn begin(
137 &mut self,
138 ) -> impl std::future::Future<Output = Result<Transaction<'_, Mssql>, Error>> + Send + '_ {
139 <Self as Connection>::begin(self)
140 }
141
142 pub(crate) fn increment_transaction_depth(&mut self) {
143 self.transaction_depth += 1;
144 }
145
146 pub(crate) fn decrement_transaction_depth(&mut self) {
147 self.transaction_depth = self.transaction_depth.saturating_sub(1);
148 }
149
150 pub(crate) fn clear_transaction_depth(&mut self) {
151 self.transaction_depth = 0;
152 }
153
154 pub(crate) async fn run_sql_batch(&mut self, sql: &str) -> Result<(), Error> {
155 self.flush().await?;
156 self.run_sql_batch_direct(sql).await
157 }
158
159 async fn run_sql_batch_direct(&mut self, sql: &str) -> Result<(), Error> {
160 let packet = build_sql_batch_packet(sql, self.packet_size()?, self.transaction_descriptor)
161 .map_err(frame_error)?;
162 self.start_response(&packet, "SQL batch").await?;
163 self.finish_response().await
164 }
165
166 pub(crate) fn queue_rollback(&mut self) {
167 let sql = match self.transaction_depth {
168 0 => return,
169 1 => {
170 self.transaction_depth = 0;
171 "ROLLBACK TRANSACTION"
172 }
173 _ => {
174 self.transaction_depth -= 1;
175 "ROLLBACK TRANSACTION sqlx_savepoint"
176 }
177 };
178
179 self.pending_rollback_sql = Some(sql);
180 }
181
182 async fn start_query(
183 &mut self,
184 sql: &str,
185 arguments: Option<&MssqlArguments>,
186 ) -> Result<(), Error> {
187 self.flush().await?;
188
189 let packet_size = self.packet_size()?;
190 let transaction_descriptor = self.transaction_descriptor;
191 let (packet, operation) = match arguments {
192 Some(arguments) if !arguments.is_empty() => {
193 let packet =
194 build_execute_sql_packet(sql, arguments, packet_size, transaction_descriptor)
195 .map_err(|error| {
196 Error::Protocol(format!("failed to encode SQL Server RPC: {error}"))
197 })?;
198 (packet, "RPC execute")
199 }
200 _ => {
201 let packet = build_sql_batch_packet(sql, packet_size, transaction_descriptor)
202 .map_err(frame_error)?;
203 (packet, "SQL batch")
204 }
205 };
206
207 self.start_response(&packet, operation).await
208 }
209
210 pub(crate) async fn run_prepare(
211 &mut self,
212 sql: &str,
213 parameters: &[MssqlTypeInfo],
214 ) -> Result<Vec<MssqlColumn>, Error> {
215 self.flush().await?;
216
217 let packet = build_prepare_packet(
218 sql,
219 parameters,
220 self.packet_size()?,
221 self.transaction_descriptor,
222 )
223 .map_err(|error| {
224 Error::Protocol(format!("failed to encode SQL Server prepare RPC: {error}"))
225 })?;
226 self.start_response(&packet, "prepare RPC").await?;
227
228 let mut columns = Vec::new();
229 let mut statement_id = None;
230 while let Some(event) = self.next_event().await? {
231 match event {
232 QueryEvent::Columns(metadata) => columns = metadata,
233 QueryEvent::ReturnValue(value) if statement_id.is_none() => {
234 statement_id = Some(<i32 as Decode<Mssql>>::decode(value.as_ref()).map_err(
235 |source| Error::ColumnDecode {
236 index: "return value".to_owned(),
237 source,
238 },
239 )?);
240 }
241 _ => {}
242 }
243 }
244
245 if let Some(statement_id) = statement_id {
246 let packet = build_unprepare_packet(
247 statement_id,
248 self.packet_size()?,
249 self.transaction_descriptor,
250 )
251 .map_err(|error| {
252 Error::Protocol(format!(
253 "failed to encode SQL Server unprepare RPC: {error}"
254 ))
255 })?;
256 self.start_response(&packet, "unprepare RPC").await?;
257 self.finish_response().await?;
258 }
259
260 Ok(columns)
261 }
262
263 fn packet_size(&self) -> Result<usize, Error> {
264 self.stream
265 .as_ref()
266 .map(|stream| stream.packet_size)
267 .ok_or_else(stream_unavailable)
268 }
269
270 async fn start_response(
271 &mut self,
272 packet: &[u8],
273 operation: &'static str,
274 ) -> Result<(), Error> {
275 let mut wire = self.stream.take().ok_or_else(stream_unavailable)?;
277 wire.write_all(packet).await.map_err(|error| {
278 context_error(
279 format!("failed to send SQL Server {operation} packet"),
280 error,
281 )
282 })?;
283 let mut response = QueryResponse {
284 operation,
285 events: QueryEvents::default(),
286 next_packet_id: None,
287 };
288 self.stream = Some(wire);
289 response.read_packet(&mut self.stream).await?;
290 self.response = Some(response);
291 Ok(())
292 }
293
294 async fn next_event(&mut self) -> Result<Option<QueryEvent>, Error> {
295 let Some(response) = &mut self.response else {
296 return Ok(None);
297 };
298 let event = response.next(&mut self.stream).await;
299 match &event {
300 Ok(Some(QueryEvent::EnvChange(change))) => self.apply_env_change(change),
301 Ok(None) => self.response = None,
302 Ok(Some(_)) | Err(Error::Database(_)) => {}
303 Err(_) => {
304 self.stream = None;
305 self.response = None;
306 }
307 }
308 event
309 }
310
311 async fn finish_response(&mut self) -> Result<(), Error> {
312 while self.next_event().await?.is_some() {}
313 Ok(())
314 }
315
316 pub(crate) fn fetch_many_sql<'e>(
317 &'e mut self,
318 sql: SqlStr,
319 arguments: Result<Option<MssqlArguments>, Error>,
320 ) -> BoxStream<'e, Result<Either<MssqlQueryResult, MssqlRow>, Error>> {
321 TryAsyncStream::new(move |rows| async move {
322 self.start_query(sql.as_str(), arguments?.as_ref()).await?;
323 while let Some(event) = self.next_event().await? {
324 match event {
325 QueryEvent::Row(row) => rows.r#yield(Either::Right(row)).await,
326 QueryEvent::Result(result) => rows.r#yield(Either::Left(result)).await,
327 _ => {}
328 }
329 }
330 Ok(())
331 })
332 .boxed()
333 }
334
335 pub(crate) async fn fetch_optional_sql(
336 &mut self,
337 sql: SqlStr,
338 arguments: Result<Option<MssqlArguments>, Error>,
339 ) -> Result<Option<MssqlRow>, Error> {
340 let mut stream = self.fetch_many_sql(sql, arguments);
341 let mut first_row = None;
342
343 while let Some(item) = stream.try_next().await? {
345 match item {
346 Either::Right(row) if first_row.is_none() => first_row = Some(row),
347 _ => {}
348 }
349 }
350
351 Ok(first_row)
352 }
353}
354
355impl Connection for MssqlConnection {
356 type Database = Mssql;
357 type Options = MssqlConnectOptions;
358
359 async fn close(mut self) -> Result<(), Error> {
360 if self.pending_rollback_sql.is_some() {
361 self.flush().await?;
362 }
363
364 if let Some(mut stream) = self.stream.take() {
365 stream.shutdown().await?;
366 }
367
368 Ok(())
369 }
370
371 async fn close_hard(mut self) -> Result<(), Error> {
372 if let Some(mut stream) = self.stream.take() {
373 stream.shutdown().await?;
374 }
375
376 Ok(())
377 }
378
379 async fn ping(&mut self) -> Result<(), Error> {
380 self.run_sql_batch("SELECT 1").await?;
381 Ok(())
382 }
383
384 fn begin(
385 &mut self,
386 ) -> impl std::future::Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
387 {
388 Transaction::begin(self, None)
389 }
390
391 fn shrink_buffers(&mut self) {}
392
393 async fn flush(&mut self) -> Result<(), Error> {
394 loop {
397 match self.next_event().await {
398 Ok(None) => break,
399 Ok(Some(_)) | Err(Error::Database(_)) => {}
400 Err(error) => return Err(error),
401 }
402 }
403 if let Some(sql) = self.pending_rollback_sql.take() {
404 self.run_sql_batch_direct(sql).await?;
405 }
406 Ok(())
407 }
408
409 fn should_flush(&self) -> bool {
410 self.response.is_some() || self.pending_rollback_sql.is_some()
411 }
412}
413
414impl<'c> Executor<'c> for &'c mut MssqlConnection {
415 type Database = Mssql;
416
417 fn fetch_many<'e, 'q, E>(
418 self,
419 mut query: E,
420 ) -> BoxStream<'e, Result<Either<MssqlQueryResult, MssqlRow>, Error>>
421 where
422 'c: 'e,
423 E: Execute<'q, Self::Database>,
424 'q: 'e,
425 E: 'q,
426 {
427 let arguments = query.take_arguments().map_err(Error::Encode);
428 let sql = query.sql();
429 self.fetch_many_sql(sql, arguments)
430 }
431
432 fn fetch_optional<'e, 'q, E>(
433 self,
434 mut query: E,
435 ) -> BoxFuture<'e, Result<Option<MssqlRow>, Error>>
436 where
437 'c: 'e,
438 E: Execute<'q, Self::Database>,
439 'q: 'e,
440 E: 'q,
441 {
442 let arguments = query.take_arguments().map_err(Error::Encode);
443 Box::pin(self.fetch_optional_sql(query.sql(), arguments))
444 }
445
446 fn prepare_with<'e>(
447 self,
448 sql: sqlx_core::sql_str::SqlStr,
449 parameters: &'e [crate::MssqlTypeInfo],
450 ) -> BoxFuture<'e, Result<MssqlStatement, Error>>
451 where
452 'c: 'e,
453 {
454 Box::pin(async move {
455 let columns = self.run_prepare(sql.as_str(), parameters).await?;
456 let parameters = if parameters.is_empty() {
457 None
458 } else {
459 Some(Either::Left(parameters.to_vec()))
460 };
461
462 Ok(MssqlStatement::with_parameters(sql, columns, parameters))
463 })
464 }
465}
466
467fn stream_unavailable() -> Error {
468 Error::Io(std::io::Error::new(
469 std::io::ErrorKind::NotConnected,
470 "SQL Server connection is closed",
471 ))
472}
473
474struct MssqlWireStream {
475 stream: MssqlStream,
476 packet_size: usize,
477}
478
479impl std::fmt::Debug for MssqlWireStream {
480 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
481 f.debug_struct("MssqlWireStream")
482 .field("encrypted", &matches!(self.stream, MssqlStream::Tls(_)))
483 .field("packet_size", &self.packet_size)
484 .finish()
485 }
486}
487
488enum MssqlStream {
489 Raw(TcpStream),
490 Tls(tokio_native_tls::TlsStream<TlsPreloginStream<TcpStream>>),
491 Taken,
492}
493
494impl MssqlWireStream {
495 async fn connect(options: &MssqlConnectOptions) -> Result<Self, Error> {
496 let port = match (options.port(), options.instance()) {
497 (Some(port), _) => port,
498 (None, Some(instance)) => ssrp::resolve_instance_port(options.host(), instance).await?,
499 (None, None) => 1433,
500 };
501
502 let stream = TcpStream::connect((options.host(), port))
503 .await
504 .map_err(|error| {
505 Error::Io(std::io::Error::new(
506 error.kind(),
507 format!(
508 "failed to connect to SQL Server at {}:{port}{}: {error}",
509 options.host(),
510 options
511 .instance()
512 .map(|instance| format!(" (instance={instance})"))
513 .unwrap_or_default()
514 ),
515 ))
516 })?;
517 let packet_size = usize::try_from(options.requested_packet_size()).map_err(|_| {
518 Error::Protocol(format!(
519 "SQL Server packet size {} does not fit usize",
520 options.requested_packet_size()
521 ))
522 })?;
523
524 Ok(Self {
525 stream: MssqlStream::Raw(stream),
526 packet_size,
527 })
528 }
529
530 async fn write_all(&mut self, bytes: &[u8]) -> Result<(), Error> {
531 match &mut self.stream {
532 MssqlStream::Raw(stream) => {
533 write_tds_packets(stream, bytes).await?;
534 }
535 MssqlStream::Tls(stream) => {
536 write_tds_packets(stream, bytes).await?;
537 }
538 MssqlStream::Taken => return Err(taken_stream_error()),
539 }
540 Ok(())
541 }
542
543 async fn shutdown(&mut self) -> Result<(), Error> {
544 match &mut self.stream {
545 MssqlStream::Raw(stream) => stream.shutdown().await?,
546 MssqlStream::Tls(stream) => stream.shutdown().await?,
547 MssqlStream::Taken => return Err(taken_stream_error()),
548 }
549 Ok(())
550 }
551
552 async fn enable_tls(&mut self, options: &MssqlConnectOptions) -> Result<(), Error> {
553 let stream = match std::mem::replace(&mut self.stream, MssqlStream::Taken) {
554 MssqlStream::Raw(stream) => stream,
555 other => {
556 self.stream = other;
557 return Ok(());
558 }
559 };
560
561 let mut stream = TlsPreloginStream::new(stream);
562 stream.start_handshake();
563
564 let domain = options
565 .hostname_in_certificate()
566 .unwrap_or_else(|| options.host());
567 let connector = build_tls_connector(options)?;
568 let mut stream = connector
569 .connect(domain, stream)
570 .await
571 .map_err(|error| {
572 Error::Tls(
573 std::io::Error::other(format!(
574 "SQL Server TLS handshake failed for host `{}` during the TDS PRELOGIN encryption upgrade \
575 (encrypt={:?}, trust_server_certificate={}, hostname_in_certificate={}, ssl_root_cert={}): {}",
576 domain,
577 options.encrypt(),
578 options.trust_server_certificate(),
579 options.hostname_in_certificate().unwrap_or("<not set>"),
580 options.ssl_root_cert().is_some(),
581 error
582 ))
583 .into(),
584 )
585 })?;
586 stream.get_mut().get_mut().get_mut().finish_handshake();
587
588 self.stream = MssqlStream::Tls(stream);
589 Ok(())
590 }
591
592 async fn read_message(&mut self) -> Result<Vec<u8>, Error> {
593 let mut expected_id = None;
594 let mut message = Vec::new();
595 loop {
596 let (header, payload) = self.read_packet(expected_id).await?;
597 message.extend_from_slice(&payload);
598 expected_id = header.next_packet_id();
599 if expected_id.is_none() {
600 return Ok(message);
601 }
602 }
603 }
604
605 async fn read_packet(
606 &mut self,
607 expected_id: Option<u8>,
608 ) -> Result<(PacketHeader, Vec<u8>), Error> {
609 let mut bytes = [0; PACKET_HEADER_LEN];
610 self.read_exact(&mut bytes).await?;
611 let header = PacketHeader::decode(&bytes).map_err(packet_error)?;
612 if header.packet_type != PacketType::TABULAR_RESULT {
613 return Err(Error::Protocol(format!(
614 "expected a SQL Server tabular result, got packet type 0x{:02x}",
615 header.packet_type.code()
616 )));
617 }
618 if let Some(expected) = expected_id {
619 if header.packet_id != expected {
620 return Err(Error::Protocol(format!(
621 "non-contiguous SQL Server packet id: expected {expected}, got {}",
622 header.packet_id
623 )));
624 }
625 }
626 let len = usize::from(header.length);
627 if len > self.packet_size {
628 return Err(Error::Protocol(format!(
629 "SQL Server packet length {len} exceeds negotiated packet size {}",
630 self.packet_size
631 )));
632 }
633
634 let mut payload = vec![0; len - PACKET_HEADER_LEN];
635 self.read_exact(&mut payload).await?;
636 Ok((header, payload))
637 }
638
639 async fn read_exact(&mut self, bytes: &mut [u8]) -> Result<(), Error> {
640 match &mut self.stream {
641 MssqlStream::Raw(stream) => {
642 stream.read_exact(bytes).await?;
643 }
644 MssqlStream::Tls(stream) => {
645 stream.read_exact(bytes).await?;
646 }
647 MssqlStream::Taken => return Err(taken_stream_error()),
648 }
649
650 Ok(())
651 }
652}
653
654async fn write_tds_packets<S>(stream: &mut S, bytes: &[u8]) -> Result<(), Error>
655where
656 S: AsyncWrite + Unpin,
657{
658 let mut offset = 0usize;
659
660 while offset < bytes.len() {
661 let packet = tds_packet_slice(bytes, offset)?;
662 stream.write_all(packet).await?;
663 offset += packet.len();
664 }
665
666 stream.flush().await?;
667 Ok(())
668}
669
670fn tds_packet_slice(bytes: &[u8], offset: usize) -> Result<&[u8], Error> {
671 let header_end = offset
672 .checked_add(PACKET_HEADER_LEN)
673 .ok_or_else(|| Error::Protocol("SQL Server outbound packet offset overflow".to_owned()))?;
674 let header_bytes = bytes.get(offset..header_end).ok_or_else(|| {
675 Error::Protocol("SQL Server outbound packet buffer ended inside a header".to_owned())
676 })?;
677 let header = PacketHeader::decode(header_bytes).map_err(packet_error)?;
678 let packet_len = usize::from(header.length);
679 let packet_end = offset
680 .checked_add(packet_len)
681 .ok_or_else(|| Error::Protocol("SQL Server outbound packet length overflow".to_owned()))?;
682
683 bytes.get(offset..packet_end).ok_or_else(|| {
684 Error::Protocol("SQL Server outbound packet buffer ended inside a packet".to_owned())
685 })
686}
687
688fn negotiate_encryption(requested: Encrypt, server: Encrypt) -> std::result::Result<bool, Error> {
689 match (requested, server) {
690 (Encrypt::NotSupported, Encrypt::NotSupported | Encrypt::Off) => Ok(false),
691 (Encrypt::NotSupported, Encrypt::On | Encrypt::Required) => Err(Error::Protocol(
692 "SQL Server requires encryption, but the client URL requested encrypt=not_supported"
693 .to_owned(),
694 )),
695 (Encrypt::Required, Encrypt::Off | Encrypt::NotSupported) => Err(Error::Tls(
696 "SQL Server TLS encryption is required but not supported by the server".into(),
697 )),
698 (Encrypt::On | Encrypt::Required, Encrypt::On | Encrypt::Required) => Ok(true),
699 (Encrypt::Off, _) | (_, Encrypt::Off) => Err(Error::Protocol(
700 "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"
701 .to_owned(),
702 )),
703 (Encrypt::On, Encrypt::NotSupported) => Ok(false),
704 }
705}
706
707fn build_tls_connector(options: &MssqlConnectOptions) -> Result<TlsConnector, Error> {
708 let mut builder = native_tls::TlsConnector::builder();
709 builder.danger_accept_invalid_certs(options.trust_server_certificate());
710 builder.danger_accept_invalid_hostnames(options.hostname_in_certificate().is_none());
711
712 if let Some(path) = options.ssl_root_cert() {
713 let cert = std::fs::read(path).map_err(|error| {
714 Error::Io(std::io::Error::new(
715 error.kind(),
716 format!(
717 "failed to read SQL Server ssl_root_cert `{}`: {error}",
718 path.display()
719 ),
720 ))
721 })?;
722 let cert = Certificate::from_pem(&cert)
723 .or_else(|_| Certificate::from_der(&cert))
724 .map_err(|error| {
725 Error::Tls(
726 format!(
727 "failed to parse SQL Server ssl_root_cert `{}` as PEM or DER: {error}",
728 path.display()
729 )
730 .into(),
731 )
732 })?;
733 builder.add_root_certificate(cert);
734 }
735
736 builder.build().map(TlsConnector::from).map_err(|error| {
737 Error::Tls(format!("failed to build SQL Server TLS connector: {error}").into())
738 })
739}
740
741fn taken_stream_error() -> Error {
742 Error::Protocol("SQL Server stream was used while TLS upgrade was in progress".to_owned())
743}
744
745fn packet_error(error: crate::protocol::packet::PacketHeaderError) -> Error {
746 Error::Protocol(error.to_string())
747}
748
749fn frame_error(error: crate::protocol::packet::PacketFrameError) -> Error {
750 Error::Protocol(error.to_string())
751}
752
753fn context_error(context: impl Into<String>, error: Error) -> Error {
754 let context = context.into();
755
756 match error {
757 Error::Io(error) => Error::Io(std::io::Error::new(
758 error.kind(),
759 format!("{context}: {error}"),
760 )),
761 Error::Tls(error) => Error::Tls(format!("{context}: {error}").into()),
762 Error::Protocol(message) => Error::Protocol(format!("{context}: {message}")),
763 error => Error::Protocol(format!("{context}: {error}")),
764 }
765}
766
767#[derive(Debug)]
768struct QueryResponse {
769 operation: &'static str,
770 events: QueryEvents,
771 next_packet_id: Option<u8>,
772}
773
774impl QueryResponse {
775 async fn read_packet(&mut self, socket: &mut Option<MssqlWireStream>) -> Result<(), Error> {
776 let mut wire = socket.take().ok_or_else(stream_unavailable)?;
778 let (header, payload) = wire
779 .read_packet(self.next_packet_id)
780 .await
781 .map_err(|error| {
782 context_error(
783 format!("failed to read SQL Server {} response", self.operation),
784 error,
785 )
786 })?;
787 *socket = Some(wire);
788 self.events.push_packet(payload.into());
789 self.next_packet_id = header.next_packet_id();
790 Ok(())
791 }
792
793 async fn next(
794 &mut self,
795 wire: &mut Option<MssqlWireStream>,
796 ) -> Result<Option<QueryEvent>, Error> {
797 loop {
798 if let Some(event) = self.events.next()? {
799 return Ok(Some(event));
800 }
801 if self.next_packet_id.is_none() {
802 self.events.finish()?;
803 return Ok(None);
804 }
805 self.read_packet(wire).await?;
806 }
807 }
808}
809
810#[cfg(test)]
811mod tests {
812 use super::*;
813
814 #[test]
815 fn negotiates_full_tls_for_required_or_mandatory_encryption() {
816 assert!(negotiate_encryption(Encrypt::On, Encrypt::On).unwrap());
817 assert!(negotiate_encryption(Encrypt::Required, Encrypt::Required).unwrap());
818 }
819
820 #[test]
821 fn allows_plaintext_only_when_explicitly_requested_and_supported() {
822 assert!(!negotiate_encryption(Encrypt::NotSupported, Encrypt::Off).unwrap());
823 assert!(negotiate_encryption(Encrypt::NotSupported, Encrypt::Required).is_err());
824 }
825
826 #[test]
827 fn rejects_login_only_tls_fallback_until_downgrade_is_available() {
828 assert!(negotiate_encryption(Encrypt::Off, Encrypt::On).is_err());
829 assert!(negotiate_encryption(Encrypt::On, Encrypt::Off).is_err());
830 }
831
832 #[test]
833 fn slices_encoded_outbound_packets_by_header_length() {
834 let bytes = crate::protocol::packet::encode_message(PacketType::RPC, &[0; 11], 12).unwrap();
835
836 let first = tds_packet_slice(&bytes, 0).unwrap();
837 assert_eq!(12, first.len());
838
839 let second = tds_packet_slice(&bytes, first.len()).unwrap();
840 assert_eq!(12, second.len());
841
842 let third = tds_packet_slice(&bytes, first.len() + second.len()).unwrap();
843 assert_eq!(11, third.len());
844 }
845
846 #[test]
847 fn rejects_truncated_outbound_packet() {
848 let bytes = crate::protocol::packet::encode_message(PacketType::RPC, &[0; 11], 12).unwrap();
849 let err = tds_packet_slice(&bytes[..bytes.len() - 1], 24).unwrap_err();
850
851 assert!(err.to_string().contains("ended inside a packet"));
852 }
853
854 #[tokio::test]
855 async fn ping_rejects_a_socket_closed_by_the_server() {
856 let (mut conn, server) = loopback_connection().await;
857 drop(server);
858
859 assert!(matches!(conn.ping().await, Err(Error::Io(_))));
860 assert!(conn.stream.is_none());
861 }
862
863 #[tokio::test]
864 async fn dropping_a_query_while_awaiting_a_reply_closes_the_socket() {
865 let (mut conn, mut server) = loopback_connection().await;
866 let mut query = Box::pin(conn.run_sql_batch("SELECT 1"));
867 let mut header = [0; PACKET_HEADER_LEN];
868
869 tokio::select! {
870 result = &mut query => panic!("query finished before the server sent a reply: {result:?}"),
871 result = server.read_exact(&mut header) => { result.unwrap(); }
872 }
873
874 assert_eq!(
875 PacketHeader::decode(&header).unwrap().packet_type,
876 PacketType::SQL_BATCH
877 );
878 drop(query);
879 assert!(matches!(
880 conn.ping().await,
881 Err(Error::Io(error)) if error.kind() == std::io::ErrorKind::NotConnected
882 ));
883 }
884
885 async fn loopback_connection() -> (MssqlConnection, TcpStream) {
886 let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
887 .await
888 .unwrap();
889 let addr = listener.local_addr().unwrap();
890 let (client, server) = tokio::join!(TcpStream::connect(addr), listener.accept());
891 let conn = MssqlConnection {
892 stream: Some(MssqlWireStream {
893 stream: MssqlStream::Raw(client.unwrap()),
894 packet_size: 4096,
895 }),
896 response: None,
897 transaction_depth: 0,
898 transaction_descriptor: 0,
899 pending_rollback_sql: None,
900 };
901
902 (conn, server.unwrap().0)
903 }
904}