Skip to main content

sqlx_sqlserver/
connection.rs

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/// SQL Server connection.
37#[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    /// Establishes a SQL Server TCP connection and completes PRELOGIN and LOGIN7.
47    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    /// Returns the current transaction depth tracked by the connection.
145    pub const fn transaction_depth(&self) -> usize {
146        self.transaction_depth
147    }
148
149    /// Begins a transaction on this connection.
150    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        // Dropping an in-flight exchange closes the socket. The next request cannot
292        // safely reuse it after a partial write or an unread reply.
293        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}