Feature | Add scaffolding for SSRP response parsing

src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/PacketBuffer.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Buffers;
+
+#nullable enable
+
+namespace Microsoft.Data.Common;
+
+/// <summary>
+/// One buffer, which may contain one unparsed packet from a single destination.
+/// </summary>
+internal sealed class PacketBuffer : ReadOnlySequenceSegment<byte>
+{
+    public PacketBuffer(ReadOnlyMemory<byte> buffer, PacketBuffer? previous)
+    {
+        Memory = buffer;
+
+        if (previous is not null)
+        {
+            previous.Next = this;
+            RunningIndex = previous.RunningIndex + previous.Memory.Length;
+        }
+        else
+        {
+            RunningIndex = 0;
+        }
+    }
+}

src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/ReadOnlySequenceUtilities.cs

@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+
+namespace Microsoft.Data.Common;
+
+internal static class ReadOnlySequenceUtilities
+{
+    /// <summary>
+    /// Reads the next byte from the sequence, advancing its position by one byte.
+    /// </summary>
+    /// <param name="sequence">The sequence to read and to advance from.</param>
+    /// <param name="currSpan">The first span in the sequence. Reassigned if the next byte can only be read from the next span.</param>
+    /// <param name="currPos">Current position in the sequence. Advanced by one byte following a successful read.</param>
+    /// <param name="value">The <see cref="byte"/> value read from <paramref name="sequence"/>.</param>
+    /// <returns><c>true</c> if <paramref name="sequence"/> was long enough to retrieve the next byte, <c>false</c> otherwise.</returns>
+    public static bool ReadByte(this ref ReadOnlySequence<byte> sequence, ref ReadOnlySpan<byte> currSpan, ref long currPos, out byte value)
+    {
+        if (sequence.Length < sizeof(byte))
+        {
+            value = default;
+            return false;
+        }
+
+        currPos += sizeof(byte);
+        if (currSpan.Length >= sizeof(byte))
+        {
+            value = currSpan[0];
+
+            sequence = sequence.Slice(sizeof(byte));
+            currSpan = currSpan.Slice(sizeof(byte));
+
+            return true;
+        }
+        else
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(byte)];
+
+            sequence.Slice(0, sizeof(byte)).CopyTo(buffer);
+            value = buffer[0];
+
+            sequence = sequence.Slice(sizeof(byte));
+            currSpan = sequence.First.Span;
+
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// Reads the next two bytes from the sequence as a <see cref="ushort"/>, advancing its position by two bytes.
+    /// </summary>
+    /// <param name="sequence">The sequence to read and to advance from.</param>
+    /// <param name="currSpan">The first span in the sequence. Reassigned if the next two bytes can only be read from the next span.</param>
+    /// <param name="currPos">Current position in the sequence. Advanced by two bytes following a successful read.</param>
+    /// <param name="value">The <see cref="ushort"/> value read from <paramref name="sequence"/></param>
+    /// <returns><c>true</c> if <paramref name="sequence"/> was long enough to retrieve the next two bytes, <c>false</c> otherwise.</returns>
+    public static bool ReadLittleEndian(this ref ReadOnlySequence<byte> sequence, ref ReadOnlySpan<byte> currSpan, ref long currPos, out ushort value)
+    {
+        if (sequence.Length < sizeof(ushort))
+        {
+            value = default;
+            return false;
+        }
+
+        currPos += sizeof(ushort);
+        if (currSpan.Length >= sizeof(ushort))
+        {
+            value = BinaryPrimitives.ReadUInt16LittleEndian(currSpan);
+
+            sequence = sequence.Slice(sizeof(ushort));
+            currSpan = currSpan.Slice(sizeof(ushort));
+
+            return true;
+        }
+        else
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(ushort)];
+
+            sequence.Slice(0, sizeof(ushort)).CopyTo(buffer);
+            value = BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+
+            sequence = sequence.Slice(sizeof(ushort));
+            currSpan = sequence.First.Span;
+
+            return true;
+        }
+    }
+}

src/Microsoft.Data.SqlClient/src/System/Diagnostics/CodeAnalysis.netfx.cs

@@ -15,6 +15,14 @@ namespace System.Diagnostics.CodeAnalysis
     internal sealed class NotNullAttribute : Attribute
     {
     }
+
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        public bool ReturnValue { get; }
+    }
 }
 
 #endif

src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/Sql/DacResponseProcessorTest.cs

@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using Xunit;
+
+namespace Microsoft.Data.Sql.UnitTests;
+
+public class DacResponseProcessorTest
+{
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.EmptyPacketBuffer), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_EmptyBuffer_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.InvalidSvrRespDacPackets), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_InvalidDacResponse_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.ValidSvrRespDacPacketBuffer), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_ValidDacResponse_ReturnsData(ReadOnlySequence<byte> packetBuffers, int expectedDacPort)
+    {
+        _ = packetBuffers;
+        _ = expectedDacPort;
+    }
+}

src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/Sql/SqlDataSourceResponseProcessorTest.cs

@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using Xunit;
+
+namespace Microsoft.Data.Sql.UnitTests;
+
+public class SqlDataSourceResponseProcessorTest
+{
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.EmptyPacketBuffer), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_EmptyBuffer_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.InvalidSvrRespPackets), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_InvalidSqlDataSourceResponse_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.InvalidRespDataPackets), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_InvalidSqlDataSourceResponse_RespData_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.InvalidTcpInfoPackets), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_InvalidSqlDataSourceResponse_TcpInfo_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.InvalidClntUcastInstSvrRespPackets), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_InvalidSqlDataSourceResponseToClntUcastInst_ReturnsFalse(ReadOnlySequence<byte> packetBuffers)
+    {
+        _ = packetBuffers;
+    }
+
+    [Theory(Skip = "Implementation in progress, see GH #3700")]
+    [MemberData(nameof(SsrpPacketTestData.ValidSvrRespPacketBuffer), MemberType = typeof(SsrpPacketTestData), DisableDiscoveryEnumeration = true)]
+    public void Process_ValidSqlDataSourceResponse_ReturnsData(ReadOnlySequence<byte> packetBuffers, string expectedVersion, int expectedTcpPort, string? expectedPipeName)
+    {
+        _ = packetBuffers;
+        _ = expectedVersion;
+        _ = expectedTcpPort;
+        _ = expectedPipeName;
+    }
+}