Merged PR 7117: Sync development with main

Sync development with main

----
#### AI description  (iteration 1)
#### PR Classification
This pull request is a large-scale code refactoring and documentation enhancement that introduces robust fuzz testing support.

#### PR Summary
The changes improve the internal APIs, module visibility, and documentation while adding extensive fuzz support and updating tests and utility scripts.
- Added a new fuzz support module (`src/fuzz_support.rs`) that re-exports internal types and provides helper functions for fuzz targets.
- Updated module visibility in core files (e.g. `lib.rs`, `connection`, `message`) and enhanced API documentation (including a new README and a documentation plan file).
- Adjusted type conversion and metadata extraction functions (in files like `bulk_copy_metadata.rs` and `query/metadata.rs`) to return more explicit types (e.g. `Option<u8>` for scale).
- Revised tests and added utility scripts (e.g. `/dev/build-fuzz.sh`) to support the new fuzz and documentation build flows.
<!-- GitOpsUserAgent=GitOps.Apps.Server.pullrequestcopilot -->

Related work items: #40377, #40829, #40924, #41302, #41412, #41497, #41728, #41762, #41830, #41851, #42206, #42218, #42220, #42221, #42278, #43063, #43130, #43131, #43132, #43133, #43134, #43135, #43136, #43137, #43144

Author: saurabh500

.github/prompts/plan-documentMssqlTdsPublicApi.prompt.md

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+# Build all fuzz targets for mssql-tds.
+# Requires: nightly toolchain and cargo-fuzz.
+
+if ! rustup toolchain list | grep -q "nightly"; then
+    echo "Installing nightly toolchain..."
+    rustup toolchain install nightly
+fi
+
+if ! cargo +nightly fuzz --version &> /dev/null 2>&1; then
+    echo "Installing cargo-fuzz..."
+    cargo +nightly install cargo-fuzz
+fi
+
+cd "$(dirname "$0")/../mssql-tds"
+cargo +nightly fuzz build

dev/build-fuzz.sh

@@ -4,6 +4,9 @@ version = "0.1.0"
 edition = "2024"
 description = "Rust implementation of the TDS (Tabular Data Stream) protocol for SQL Server"
 license = "MIT"
+readme = "README.md"
+keywords = ["sql-server", "tds", "mssql", "database", "async"]
+categories = ["database", "network-programming"]
 
 [features]
 default = ["integrated-auth"]

mssql-tds/Cargo.toml

@@ -0,0 +1,63 @@
+# mssql-tds
+
+Async Rust implementation of the TDS (Tabular Data Stream) protocol for SQL Server
+and Azure SQL Database.
+
+## What it does
+
+Low-level TDS client handling connection negotiation (prelogin, TLS, login7),
+query execution, result set streaming, bulk copy, RPC calls, and transaction
+management. Built on Tokio.
+
+## Feature flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `integrated-auth` | **yes** | Enables both `sspi` and `gssapi` |
+| `sspi` | via `integrated-auth` | Windows SSPI (Kerberos/NTLM) |
+| `gssapi` | via `integrated-auth` | Unix GSSAPI (Kerberos) via runtime `dlopen` |
+
+Disable the default to drop platform-specific auth dependencies:
+
+```toml
+mssql-tds = { version = "0.1", default-features = false }
+```
+
+## Quick start
+
+```rust,no_run
+use mssql_tds::connection::client_context::ClientContext;
+use mssql_tds::connection::tds_client::ResultSetClient;
+use mssql_tds::connection_provider::tds_connection_provider::TdsConnectionProvider;
+use mssql_tds::core::TdsResult;
+
+#[tokio::main]
+async fn main() -> TdsResult<()> {
+    let mut context = ClientContext::default();
+    context.user_name = std::env::var("DB_USER").unwrap_or("<user>".into());
+    context.password = std::env::var("DB_PASSWORD").unwrap_or("<password>".into());
+    context.database = "master".into();
+
+    let provider = TdsConnectionProvider {};
+    let mut client = provider
+        .create_client(context, "tcp:localhost,1433", None)
+        .await?;
+
+    client
+        .execute("SELECT 1 AS value".into(), None, None)
+        .await?;
+
+    if let Some(rs) = client.get_current_resultset() {
+        while let Some(row) = rs.next_row().await? {
+            println!("{row:?}");
+        }
+    }
+
+    client.close_query().await?;
+    Ok(())
+}
+```
+
+## License
+
+MIT

mssql-tds/README.md

@@ -20,252 +20,7 @@
 
 use libfuzzer_sys::fuzz_target;
 use mssql_tds::connection::client_context::ClientContext;
-use mssql_tds::fuzz_support::{MockTransport, TdsConnectionProvider, TdsPacketReader};
-use mssql_tds::core::TdsResult;
-use std::io::{Error, ErrorKind};
-
-/// Simple reader that wraps fuzz input data
-struct FuzzReader {
-    data: Vec<u8>,
-    position: usize,
-}
-
-impl FuzzReader {
-    fn new(data: &[u8]) -> Self {
-        Self {
-            data: data.to_vec(),
-            position: 0,
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl TdsPacketReader for FuzzReader {
-    async fn read_byte(&mut self) -> TdsResult<u8> {
-        if self.position >= self.data.len() {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::UnexpectedEof,
-                "EOF",
-            )));
-        }
-        let byte = self.data[self.position];
-        self.position += 1;
-        Ok(byte)
-    }
-
-    async fn read_int16_big_endian(&mut self) -> TdsResult<i16> {
-        let mut buf = [0u8; 2];
-        self.read_bytes(&mut buf).await?;
-        Ok(i16::from_be_bytes(buf))
-    }
-
-    async fn read_int32_big_endian(&mut self) -> TdsResult<i32> {
-        let mut buf = [0u8; 4];
-        self.read_bytes(&mut buf).await?;
-        Ok(i32::from_be_bytes(buf))
-    }
-
-    async fn read_uint40(&mut self) -> TdsResult<u64> {
-        let mut buf = [0u8; 8];
-        self.read_bytes(&mut buf[..5]).await?;
-        Ok(u64::from_le_bytes(buf))
-    }
-
-    async fn read_float32(&mut self) -> TdsResult<f32> {
-        let mut buf = [0u8; 4];
-        self.read_bytes(&mut buf).await?;
-        Ok(f32::from_le_bytes(buf))
-    }
-
-    async fn read_float64(&mut self) -> TdsResult<f64> {
-        let mut buf = [0u8; 8];
-        self.read_bytes(&mut buf).await?;
-        Ok(f64::from_le_bytes(buf))
-    }
-
-    async fn read_uint16(&mut self) -> TdsResult<u16> {
-        let mut buf = [0u8; 2];
-        self.read_bytes(&mut buf).await?;
-        Ok(u16::from_le_bytes(buf))
-    }
-
-    async fn read_uint32(&mut self) -> TdsResult<u32> {
-        let mut buf = [0u8; 4];
-        self.read_bytes(&mut buf).await?;
-        Ok(u32::from_le_bytes(buf))
-    }
-
-    async fn read_uint64(&mut self) -> TdsResult<u64> {
-        let mut buf = [0u8; 8];
-        self.read_bytes(&mut buf).await?;
-        Ok(u64::from_le_bytes(buf))
-    }
-
-    async fn read_int16(&mut self) -> TdsResult<i16> {
-        let mut buf = [0u8; 2];
-        self.read_bytes(&mut buf).await?;
-        Ok(i16::from_le_bytes(buf))
-    }
-
-    async fn read_uint24(&mut self) -> TdsResult<u32> {
-        let mut buf = [0u8; 4];
-        self.read_bytes(&mut buf[..3]).await?;
-        Ok(u32::from_le_bytes(buf))
-    }
-
-    async fn read_int32(&mut self) -> TdsResult<i32> {
-        let mut buf = [0u8; 4];
-        self.read_bytes(&mut buf).await?;
-        Ok(i32::from_le_bytes(buf))
-    }
-
-    async fn read_int64(&mut self) -> TdsResult<i64> {
-        let mut buf = [0u8; 8];
-        self.read_bytes(&mut buf).await?;
-        Ok(i64::from_le_bytes(buf))
-    }
-
-    async fn read_bytes(&mut self, buf: &mut [u8]) -> TdsResult<usize> {
-        // Use checked arithmetic to prevent overflow
-        let end_position = self.position.checked_add(buf.len()).ok_or_else(|| {
-            mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidInput,
-                "buffer length causes position overflow",
-            ))
-        })?;
-        
-        if end_position > self.data.len() {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::UnexpectedEof,
-                "EOF",
-            )));
-        }
-        buf.copy_from_slice(&self.data[self.position..end_position]);
-        self.position = end_position;
-        Ok(buf.len())
-    }
-
-    async fn read_u8_varbyte(&mut self) -> TdsResult<Vec<u8>> {
-        let len = self.read_byte().await? as usize;
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if len > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", len, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; len];
-        self.read_bytes(&mut buf).await?;
-        Ok(buf)
-    }
-
-    async fn read_u16_varbyte(&mut self) -> TdsResult<Vec<u8>> {
-        let len = self.read_uint16().await? as usize;
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if len > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", len, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; len];
-        self.read_bytes(&mut buf).await?;
-        Ok(buf)
-    }
-
-    async fn read_varchar_u16_length(&mut self) -> TdsResult<Option<String>> {
-        let len = self.read_uint16().await?;
-        if len == 0xFFFF {
-            return Ok(None);
-        }
-        let byte_len = (len as usize) * 2;
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if byte_len > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", byte_len, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; byte_len];
-        self.read_bytes(&mut buf).await?;
-        String::from_utf16(&buf.chunks_exact(2).map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])).collect::<Vec<u16>>())
-            .map(Some)
-            .map_err(|e| mssql_tds::error::Error::Io(Error::new(ErrorKind::InvalidData, e)))
-    }
-
-    async fn read_varchar_u8_length(&mut self) -> TdsResult<String> {
-        let len = self.read_byte().await? as usize;
-        let byte_len = len * 2;
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if byte_len > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", byte_len, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; byte_len];
-        self.read_bytes(&mut buf).await?;
-        String::from_utf16(&buf.chunks_exact(2).map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])).collect::<Vec<u16>>())
-            .map_err(|e| mssql_tds::error::Error::Io(Error::new(ErrorKind::InvalidData, e)))
-    }
-
-    async fn read_unicode(&mut self, string_length: usize) -> TdsResult<String> {
-        let byte_len = string_length * 2;
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if byte_len > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", byte_len, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; byte_len];
-        self.read_bytes(&mut buf).await?;
-        String::from_utf16(&buf.chunks_exact(2).map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])).collect::<Vec<u16>>())
-            .map_err(|e| mssql_tds::error::Error::Io(Error::new(ErrorKind::InvalidData, e)))
-    }
-
-    async fn read_unicode_with_byte_length(&mut self, byte_length: usize) -> TdsResult<String> {
-        const MAX_ALLOC: usize = 1024 * 1024;
-        if byte_length > MAX_ALLOC {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidData,
-                format!("Allocation size {} exceeds max {}", byte_length, MAX_ALLOC),
-            )));
-        }
-        let mut buf = vec![0u8; byte_length];
-        self.read_bytes(&mut buf).await?;
-        String::from_utf16(&buf.chunks_exact(2).map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])).collect::<Vec<u16>>())
-            .map_err(|e| mssql_tds::error::Error::Io(Error::new(ErrorKind::InvalidData, e)))
-    }
-
-    async fn skip_bytes(&mut self, skip_count: usize) -> TdsResult<()> {
-        // Use checked arithmetic to prevent overflow
-        let new_position = self.position.checked_add(skip_count).ok_or_else(|| {
-            mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::InvalidInput,
-                "skip_count causes position overflow",
-            ))
-        })?;
-        
-        if new_position > self.data.len() {
-            return Err(mssql_tds::error::Error::Io(Error::new(
-                ErrorKind::UnexpectedEof,
-                "EOF",
-            )));
-        }
-        self.position = new_position;
-        Ok(())
-    }
-
-    async fn cancel_read_stream(&mut self) -> TdsResult<()> {
-        // No-op for fuzzing
-        Ok(())
-    }
-
-    fn reset_reader(&mut self) {
-        self.position = 0;
-    }
-}
+use mssql_tds::fuzz_support::{FuzzReader, MockTransport, TdsConnectionProvider};
 
 fuzz_target!(|data: &[u8]| {
     // Need at least some data to work with