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