Merged PR 7346: Sync dev with main

Sync dev with main

Related work items: #40377, #40829, #40924, #41302, #41412, #41497, #41728, #41762, #41830, #41851, #42218, #42220, #42221, #42278, #43144, #43310, #43311, #43313, #43314, #43315, #43316, #43861, #43862, #43863, #43976, #43988

Author: saurabh500

.pipeline/templates/build-template.yml

@@ -135,6 +135,13 @@ steps:
     workingDirectory: "$(Build.SourcesDirectory)"
     displayName: Save code coverage in lcov format (mssql-tds package only)
 
+  - ${{ if eq(parameters.osType, 'Linux') }}:
+    - bash: |
+        echo "Running mssql-py-core Rust unit tests..."
+        cd mssql-py-core && cargo test --frozen -- --show-output
+      displayName: Run Rust unit tests (mssql-py-core)
+      condition: and(succeeded(), eq(variables['Build.Reason'], 'PullRequest'))
+
   - ${{ if eq(parameters.osType, 'Linux') }}:
     - bash: |
         echo "Running Python tests for mssql-py-core..."

docs/ssrp-plan.md

@@ -65,15 +65,19 @@ pub struct PyConnectionInfo {
     /// Whether the client authenticated successfully
     #[pyo3(get)]
     pub authenticated: bool,
+    /// User Agent sent by the client
+    #[pyo3(get)]
+    pub user_agent: Option<String>,
 }
 
 #[pymethods]
 impl PyConnectionInfo {
     fn __repr__(&self) -> String {
         format!(
-            "ConnectionInfo(addr='{}', authenticated={}, has_token={})",
+            "ConnectionInfo(addr='{}', authenticated={}, user_agent='{:?}', has_token={})",
             self.addr,
             self.authenticated,
+            self.user_agent,
             self.access_token.is_some()
         )
     }
@@ -239,6 +243,7 @@ impl PyMockTdsServer {
                     addr: info.addr.to_string(),
                     access_token: info.received_token_as_string(),
                     authenticated: info.authenticated,
+                    user_agent: info.user_agent.clone(),
                 })
                 .collect()
         }))

mssql-mock-tds-py/src/lib.rs

@@ -158,6 +158,7 @@ pub enum TokenType {
 
 /// FedAuth feature extension ID
 pub const FEATURE_EXT_FEDAUTH: u8 = 0x02;
+pub const FEATURE_EXT_USER_AGENT: u8 = 0x10;
 /// FedAuth terminator
 pub const FEATURE_EXT_TERMINATOR: u8 = 0xFF;
 
@@ -172,6 +173,8 @@ pub struct Login7AuthInfo {
     pub fedauth_library: u8,
     /// Server name from Login7 packet (the data source string sent by client)
     pub server_name: Option<String>,
+    /// User Agent string from Login7 packet (if present)
+    pub user_agent: Option<String>,
 }
 
 /// Parse Login7 packet to extract FedAuth feature extension with access token
@@ -322,7 +325,23 @@ pub fn parse_login7_auth(packet_data: &[u8]) -> Login7AuthInfo {
                     }
                 }
             }
-            break;
+        } else if feature_id == FEATURE_EXT_USER_AGENT && i + 5 + feat_len <= data.len() {
+            let feat_data = &data[i + 5..i + 5 + feat_len];
+            if feat_data.len().is_multiple_of(2) {
+                let u16_chars: Vec<u16> = feat_data
+                    .chunks_exact(2)
+                    .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+                    .collect();
+                if let Ok(user_agent) = String::from_utf16(&u16_chars) {
+                    debug!("Parsed UserAgent from Login7 (len: {})", user_agent.len());
+                    auth_info.user_agent = Some(user_agent);
+                }
+            } else {
+                debug!(
+                    "Skipping UserAgent FeatureExtension due to odd data length: {}",
+                    feat_len
+                );
+            }
         }
 
         // Skip to next feature entry
@@ -607,8 +626,15 @@ pub fn build_query_result(response: &crate::query_response::QueryResponse) -> By
     for col in &response.columns {
         result.put_u32_le(0); // UserType
         result.put_u16_le(0x0000); // Flags: not nullable, no special flags
-        result.put_u8(col.data_type.tds_type_code()); // Type code
-        result.put_u8(col.data_type.max_length()); // Max length
+        result.put_u8(col.data_type.tds_type_code());
+        if col.data_type == crate::query_response::SqlDataType::NVarChar {
+            // Required to support string responses (e.g., @@USERAGENT).
+            // TDS ColMetadata mandates a 5-byte collation suffix for variable-length types.
+            result.put_u16_le(8000); // NVARCHAR(4000) max byte capacity
+            result.put_slice(&[0x09, 0x04, 0xD0, 0x00, 0x34]); // SQL_Latin1_General_CP1_CI_AS
+        } else {
+            result.put_u8(col.data_type.max_length());
+        }
 
         // Column name (UTF-16LE)
         let name_len = col.name.chars().count() as u8;
@@ -883,4 +909,58 @@ mod tests {
         // After header, should have EnvChange token (0xE3)
         assert_eq!(response[PACKET_HEADER_SIZE], TokenType::EnvChange as u8);
     }
+
+    #[test]
+    fn test_parse_login7_user_agent() {
+        let user_agent = "TestAgent";
+        let utf16_bytes: Vec<u8> = user_agent
+            .encode_utf16()
+            .flat_map(|ch| ch.to_le_bytes().into_iter())
+            .collect();
+
+        let mut payload = BytesMut::zeroed(100);
+
+        // OptionFlags3 at byte 27: set FeatureExt bit (0x10)
+        payload[27] = 0x10;
+
+        // FeatureExt table entry at bytes 56-57 (points to offset 60)
+        payload[56] = 60;
+        payload[57] = 0;
+
+        // DWORD at byte 60 pointing to the actual feature data at byte 64
+        payload[60..64].copy_from_slice(&64u32.to_le_bytes());
+
+        // Truncate the buffer at 64 so we can append the feature bytes directly
+        payload.truncate(64);
+
+        // Append UserAgent feature
+        payload.put_u8(FEATURE_EXT_USER_AGENT); // 0x10
+        payload.put_u32_le(utf16_bytes.len() as u32);
+        payload.put_slice(&utf16_bytes);
+        payload.put_u8(FEATURE_EXT_TERMINATOR); // 0xFF
+
+        let result = parse_login7_auth(&payload);
+        assert_eq!(result.user_agent.unwrap(), "TestAgent");
+    }
+
+    #[test]
+    fn test_parse_login7_odd_length_user_agent() {
+        let mut payload = BytesMut::zeroed(100);
+        payload[27] = 0x10; // OptionFlags3 (FeatureExt bit)
+        payload[56] = 60; // Option offset
+        payload[57] = 0;
+        payload[60..64].copy_from_slice(&64u32.to_le_bytes()); // Feature offset
+        payload.truncate(64);
+
+        // FeatureId (1 byte) = 2 (UserAgent)
+        // FeatureDataLen (4 bytes) = 5 (odd length)
+        // FeatureData (5 bytes) = [1, 2, 3, 4, 5]
+        payload.put_u8(FEATURE_EXT_USER_AGENT); // 2
+        payload.put_u32_le(5);
+        payload.put_slice(&[1, 2, 3, 4, 5]);
+        payload.put_u8(FEATURE_EXT_TERMINATOR); // 0xFF
+
+        let result = parse_login7_auth(&payload);
+        assert_eq!(result.user_agent, None);
+    }
 }

mssql-mock-tds/src/protocol.rs

@@ -17,6 +17,8 @@ pub enum SqlDataType {
     Int,
     /// BigInt - 8 byte integer
     BigInt,
+    /// NVarChar - UTF16 string
+    NVarChar,
 }
 
 impl SqlDataType {
@@ -27,6 +29,7 @@ impl SqlDataType {
             SqlDataType::SmallInt => 0x26, // IntN with length 2
             SqlDataType::Int => 0x26,      // IntN with length 4
             SqlDataType::BigInt => 0x26,   // IntN with length 8
+            SqlDataType::NVarChar => 0xE7, // NVarCharType
         }
     }
 
@@ -37,6 +40,7 @@ impl SqlDataType {
             SqlDataType::SmallInt => 2,
             SqlDataType::Int => 4,
             SqlDataType::BigInt => 8,
+            SqlDataType::NVarChar => 255, // Handled specially
         }
     }
 }
@@ -48,6 +52,7 @@ pub enum ColumnValue {
     SmallInt(i16),
     Int(i32),
     BigInt(i64),
+    NVarChar(String),
     Null,
 }
 
@@ -59,6 +64,7 @@ impl ColumnValue {
             ColumnValue::SmallInt(_) => SqlDataType::SmallInt,
             ColumnValue::Int(_) => SqlDataType::Int,
             ColumnValue::BigInt(_) => SqlDataType::BigInt,
+            ColumnValue::NVarChar(_) => SqlDataType::NVarChar,
             ColumnValue::Null => SqlDataType::Int, // Default to Int for NULL
         }
     }
@@ -82,6 +88,14 @@ impl ColumnValue {
                 buf.put_u8(8); // Length indicator
                 buf.put_i64_le(*v);
             }
+            ColumnValue::NVarChar(v) => {
+                let utf16_bytes: Vec<u8> = v
+                    .encode_utf16()
+                    .flat_map(|ch| ch.to_le_bytes().into_iter())
+                    .collect();
+                buf.put_u16_le(utf16_bytes.len() as u16);
+                buf.put_slice(&utf16_bytes);
+            }
             ColumnValue::Null => {
                 buf.put_u8(0); // Length 0 means NULL for IntN
             }
@@ -196,3 +210,61 @@ impl Default for QueryRegistry {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sql_data_types() {
+        assert_eq!(SqlDataType::TinyInt.tds_type_code(), 0x26);
+        assert_eq!(SqlDataType::SmallInt.tds_type_code(), 0x26);
+        assert_eq!(SqlDataType::Int.tds_type_code(), 0x26);
+        assert_eq!(SqlDataType::BigInt.tds_type_code(), 0x26);
+        assert_eq!(SqlDataType::NVarChar.tds_type_code(), 0xE7);
+
+        assert_eq!(SqlDataType::TinyInt.max_length(), 1);
+        assert_eq!(SqlDataType::SmallInt.max_length(), 2);
+        assert_eq!(SqlDataType::Int.max_length(), 4);
+        assert_eq!(SqlDataType::BigInt.max_length(), 8);
+        assert_eq!(SqlDataType::NVarChar.max_length(), 255);
+    }
+
+    #[test]
+    fn test_column_value_write() {
+        let mut buf = bytes::BytesMut::new();
+
+        let null_val = ColumnValue::Null;
+        assert_eq!(null_val.data_type(), SqlDataType::Int);
+        null_val.write_to_buffer(&mut buf);
+        assert_eq!(&buf[..], &[0]);
+        buf.clear();
+
+        let nvarchar_val = ColumnValue::NVarChar("test".to_string());
+        assert_eq!(nvarchar_val.data_type(), SqlDataType::NVarChar);
+        nvarchar_val.write_to_buffer(&mut buf);
+        // length is 4 u16 chars => 8 bytes, so 0x08 0x00 is the length followed by the utf16 LE bytes
+        assert_eq!(&buf[0..2], &[8, 0]);
+        buf.clear();
+
+        let int_val = ColumnValue::Int(1);
+        assert_eq!(int_val.data_type(), SqlDataType::Int);
+        int_val.write_to_buffer(&mut buf);
+        assert_eq!(&buf[..], &[4, 1, 0, 0, 0]);
+    }
+
+    #[test]
+    fn test_select_nvarchar_type() {
+        let mut registry = QueryRegistry::new();
+        registry.register(
+            "SELECT 'test'",
+            QueryResponse::new(
+                vec![ColumnDefinition::new("", SqlDataType::NVarChar)],
+                vec![Row::new(vec![ColumnValue::NVarChar("test".to_string())])],
+            ),
+        );
+        let resp = registry.get("SELECT 'test'").unwrap();
+        assert_eq!(resp.columns.len(), 1);
+        assert_eq!(resp.rows.len(), 1);
+    }
+}

mssql-mock-tds/src/query_response.rs

@@ -53,6 +53,8 @@ pub struct ConnectionProcessor {
     is_authenticated: bool,
     /// Access token received during FedAuth authentication (if any)
     received_token: Option<Vec<u8>>,
+    /// User Agent received during authentication (if any)
+    pub user_agent: Option<String>,
     /// Reference to the shared query registry
     query_registry: Arc<Mutex<QueryRegistry>>,
     /// Packet buffer for this connection
@@ -68,6 +70,7 @@ impl ConnectionProcessor {
             addr,
             is_authenticated: false,
             received_token: None,
+            user_agent: None,
             query_registry,
             buffer: BytesMut::with_capacity(4096),
             redirection: None,
@@ -84,6 +87,7 @@ impl ConnectionProcessor {
             addr,
             is_authenticated: false,
             received_token: None,
+            user_agent: None,
             query_registry,
             buffer: BytesMut::with_capacity(4096),
             redirection,
@@ -166,6 +170,7 @@ impl ConnectionProcessor {
                 // Parse Login7 packet body (skip header) for authentication info
                 let packet_body = &packet_data[PACKET_HEADER_SIZE..];
                 let auth_info = parse_login7_auth(packet_body);
+                self.user_agent = auth_info.user_agent.clone();
 
                 // Log the server name sent by client (important for verifying redirection behavior)
                 if let Some(ref server_name) = auth_info.server_name {
@@ -329,6 +334,8 @@ pub struct ConnectionInfo {
     pub received_token: Option<Vec<u8>>,
     /// Whether the client authenticated successfully
     pub authenticated: bool,
+    /// User Agent received during authentication (if any)
+    pub user_agent: Option<String>,
 }
 
 impl ConnectionInfo {
@@ -346,6 +353,10 @@ impl ConnectionInfo {
             }
         })
     }
+    /// Get the user agent received during authentication
+    pub fn received_user_agent(&self) -> Option<String> {
+        self.user_agent.clone()
+    }
 }
 
 impl ConnectionStore {
@@ -361,6 +372,7 @@ impl ConnectionStore {
             addr: processor.addr(),
             received_token: processor.received_token().map(|t| t.to_vec()),
             authenticated: processor.is_authenticated(),
+            user_agent: processor.user_agent.clone(),
         };
         self.connections.insert(processor.addr(), info);
     }
@@ -1007,6 +1019,8 @@ async fn handle_connection(
 
                 PacketType::Login7 => {
                     debug!("Handling Login7");
+                    let packet_body = &packet_data[PACKET_HEADER_SIZE..];
+                    let _auth_info = parse_login7_auth(packet_body);
                     is_authenticated = true;
 
                     // Build response with LoginAck + EnvChange + Done

mssql-mock-tds/src/server.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mssql-py-core"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 publish = false
 

mssql-py-core/Cargo.toml

@@ -1230,17 +1230,12 @@ impl PythonRowAdapter {
         }
 
         // Default to DATETIME format
-        // Calculate time in 1/300th seconds
-        let total_ms = (hour as u64) * 3_600_000
-            + (minute as u64) * 60_000
-            + (second as u64) * 1_000
-            + (microsecond as u64) / 1_000;
-
-        let time_ticks = ((total_ms * 300) / 1000) as u32;
+        let (final_days, time_ticks) =
+            crate::types::datetime_to_ticks(days, hour, minute, second, microsecond)?;
 
         Ok(ColumnValues::DateTime(
             mssql_tds::datatypes::column_values::SqlDateTime {
-                days,
+                days: final_days,
                 time: time_ticks,
             },
         ))