fix: Add retry-safe download and transport fixes

Add tests and changes to ensure download retries are safe and transports are thread-safe. Tests: add RetryAwareDownloadCaptureTransport and NonSeekableStream plus two tests verifying retry uses initial stream position and non-seekable streams do not retry. InternalDownloadDataStream: capture initial stream position and only attempt retries when stream.CanSeek; return a failed FastbootResponse immediately for non-seekable streams on exception. TcpTransport: introduce an _ioLock and synchronize read/write paths; fix message-length read logic to avoid races. UdpTransport: extract common packet exchange logic into ExchangePacketSequence, consolidate SendSinglePacket/Receive handling, and correct payload/collector/output handling and overflow checks. Project: restrict Fastboot project TargetFrameworks to net10.0. These changes fix concurrency/race issues and make download retry behavior deterministic and testable.

Author: 13584452567

FirmwareKit.Comm.Fastboot.Tests/FastbootProtocolTests.cs

@@ -129,6 +129,96 @@ public long Write(byte[] data, int length)
             public void Dispose() { }
         }
 
+        private sealed class RetryAwareDownloadCaptureTransport : IFastbootTransport
+        {
+            private readonly Queue<byte[]> _readQueue = new();
+            private int _pendingDownloadBytes;
+            private bool _failedFirstPayloadWrite;
+
+            public MemoryStream DownloadPayload { get; } = new();
+
+            public RetryAwareDownloadCaptureTransport(bool failFirstPayloadWrite)
+            {
+                _failedFirstPayloadWrite = failFirstPayloadWrite;
+            }
+
+            public byte[] Read(int length)
+            {
+                if (_readQueue.Count == 0)
+                {
+                    return Array.Empty<byte>();
+                }
+                return _readQueue.Dequeue();
+            }
+
+            public long Write(byte[] data, int length)
+            {
+                string command = Encoding.UTF8.GetString(data, 0, length);
+                if (command.Equals("getvar:has-crc", StringComparison.OrdinalIgnoreCase))
+                {
+                    _readQueue.Enqueue(Encoding.UTF8.GetBytes("OKAYno"));
+                    return length;
+                }
+
+                if (command.StartsWith("download:", StringComparison.OrdinalIgnoreCase))
+                {
+                    string hex = command.Substring("download:".Length);
+                    int size = int.Parse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+                    _pendingDownloadBytes = size;
+                    _readQueue.Enqueue(Encoding.UTF8.GetBytes($"DATA{size:x8}"));
+                    return length;
+                }
+
+                if (_pendingDownloadBytes > 0)
+                {
+                    if (_failedFirstPayloadWrite)
+                    {
+                        _failedFirstPayloadWrite = false;
+                        return Math.Max(0, length - 1);
+                    }
+
+                    DownloadPayload.Write(data, 0, length);
+                    _pendingDownloadBytes -= length;
+                    if (_pendingDownloadBytes <= 0)
+                    {
+                        _readQueue.Enqueue(Encoding.UTF8.GetBytes("OKAY"));
+                    }
+                    return length;
+                }
+
+                _readQueue.Enqueue(Encoding.UTF8.GetBytes("OKAY"));
+                return length;
+            }
+
+            public void Dispose() { }
+        }
+
+        private sealed class NonSeekableStream : Stream
+        {
+            private readonly Stream _inner;
+
+            public NonSeekableStream(Stream inner)
+            {
+                _inner = inner;
+            }
+
+            public override bool CanRead => _inner.CanRead;
+            public override bool CanSeek => false;
+            public override bool CanWrite => _inner.CanWrite;
+            public override long Length => throw new NotSupportedException();
+            public override long Position
+            {
+                get => throw new NotSupportedException();
+                set => throw new NotSupportedException();
+            }
+
+            public override void Flush() => _inner.Flush();
+            public override int Read(byte[] buffer, int offset, int count) => _inner.Read(buffer, offset, count);
+            public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+            public override void SetLength(long value) => _inner.SetLength(value);
+            public override void Write(byte[] buffer, int offset, int count) => _inner.Write(buffer, offset, count);
+        }
+
         [Fact]
         public void HandleResponse_Success_ReturnsOkay()
         {
@@ -302,6 +392,37 @@ public void DownloadDataStream_DataSizeMismatch_Fails()
             Assert.DoesNotContain("Short write", response.Response);
         }
 
+        [Fact]
+        public void DownloadDataStream_Retry_UsesInitialStreamPosition()
+        {
+            var transport = new RetryAwareDownloadCaptureTransport(failFirstPayloadWrite: true);
+            var util = new FastbootDriver(transport);
+
+            byte[] source = new byte[] { 0xAA, 0xBB, 0x01, 0x02, 0x03, 0x04 };
+            using var stream = new MemoryStream(source);
+            stream.Position = 2;
+
+            var response = util.DownloadData(stream, 4);
+
+            Assert.Equal(FastbootState.Success, response.Result);
+            Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, transport.DownloadPayload.ToArray());
+        }
+
+        [Fact]
+        public void DownloadDataStream_NonSeekable_DoesNotRetry()
+        {
+            var transport = new RetryAwareDownloadCaptureTransport(failFirstPayloadWrite: true);
+            var util = new FastbootDriver(transport);
+
+            using var baseStream = new MemoryStream(new byte[] { 0x01, 0x02, 0x03, 0x04 });
+            using var nonSeek = new NonSeekableStream(baseStream);
+
+            var response = util.DownloadData(nonSeek, 4);
+
+            Assert.Equal(FastbootState.Fail, response.Result);
+            Assert.Contains("non-seekable stream", response.Response);
+        }
+
         [Fact]
         public void DownloadDataBytes_ZeroLength_Fails()
         {

FirmwareKit.Comm.Fastboot/Backend/Network/TcpTransport.cs

@@ -8,6 +8,7 @@ public class TcpTransport : IFastbootBufferedTransport
 {
     private const int DefaultIoTimeoutMs = 30000;
     private readonly TcpClient _client = new();
+    private readonly object _ioLock = new();
     private readonly byte[] _readLenBuffer = new byte[8];
     private readonly byte[] _writeLenBuffer = new byte[8];
     private NetworkStream? _stream;
@@ -96,30 +97,36 @@ public int ReadInto(byte[] buffer, int offset, int length)
             throw new ArgumentOutOfRangeException(nameof(length));
         }
 
-        if (_messageBytesLeft == 0)
+        lock (_ioLock)
         {
-            if (ReadFully(_readLenBuffer, 0, 8) != 8)
+            if (_messageBytesLeft == 0)
             {
-                throw new Exception("Failed to read message length from TCP stream.");
+                if (ReadFully(_readLenBuffer, 0, 8) != 8)
+                {
+                    throw new Exception("Failed to read message length from TCP stream.");
+                }
+                _messageBytesLeft = BinaryPrimitives.ReadInt64BigEndian(_readLenBuffer);
             }
-            _messageBytesLeft = BinaryPrimitives.ReadInt64BigEndian(_readLenBuffer);
-        }
 
-        int toRead = (int)Math.Min(length, _messageBytesLeft);
-        int actuallyRead = ReadFully(buffer, offset, toRead);
-        _messageBytesLeft -= actuallyRead;
-        return actuallyRead;
+            int toRead = (int)Math.Min(length, _messageBytesLeft);
+            int actuallyRead = ReadFully(buffer, offset, toRead);
+            _messageBytesLeft -= actuallyRead;
+            return actuallyRead;
+        }
     }
 
     public long Write(byte[] data, int length)
     {
         if (_stream == null) throw new InvalidOperationException("Stream not initialized");
-        BinaryPrimitives.WriteInt64BigEndian(_writeLenBuffer, length);
+        lock (_ioLock)
+        {
+            BinaryPrimitives.WriteInt64BigEndian(_writeLenBuffer, length);
 
-        _stream.Write(_writeLenBuffer, 0, 8);
-        _stream.Write(data, 0, length);
-        _stream.Flush();
-        return length;
+            _stream.Write(_writeLenBuffer, 0, 8);
+            _stream.Write(data, 0, length);
+            _stream.Flush();
+            return length;
+        }
     }
 
     public void Dispose()