Skip to main content

sqlx_sqlserver/
connection.rs

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/// SQL Server connection.
34#[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    /// Establishes a SQL Server TCP connection and completes PRELOGIN and LOGIN7.
45    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    /// Returns the current transaction depth tracked by the connection.
131    pub const fn transaction_depth(&self) -> usize {
132        self.transaction_depth
133    }
134
135    /// Begins a transaction on this connection.
136    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        // A cancelled write or partial packet read leaves the socket out of sync.
276        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        // A batch may report an error or change connection state after its first row.
344        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        // If the caller dropped a row stream, consume its remaining tokens
395        // before encoding a new request with this session's transaction descriptor.
396        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        // read_exact may have consumed part of a packet if this future is cancelled.
777        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}