pr comments

Author: GarrettBeatty

sdk/src/Services/S3/Custom/Transfer/Internal/ChunkedBufferStream.cs

@@ -42,6 +42,12 @@ namespace Amazon.S3.Transfer.Internal
     /// <item>Present standard Stream interface for easy integration</item>
     /// </list>
     /// 
+    /// <para><strong>Size Limits:</strong></para>
+    /// <para>
+    /// Maximum supported stream size is approximately 175TB (int.MaxValue * CHUNK_SIZE bytes).
+    /// This limit exists because chunk indexing uses int for List indexing.
+    /// </para>
+    /// 
     /// <para><strong>Usage Pattern:</strong></para>
     /// <code>
     /// var stream = new ChunkedBufferStream();
@@ -66,6 +72,12 @@ internal class ChunkedBufferStream : Stream
         /// </summary>
         private const int CHUNK_SIZE = 81920; // 80KB - safely below 85KB LOH threshold
 
+        /// <summary>
+        /// Maximum supported stream size. This limit exists because chunk indexing uses int for List indexing.
+        /// With 80KB chunks, this allows approximately 175TB of data.
+        /// </summary>
+        private const long MAX_STREAM_SIZE = (long)int.MaxValue * CHUNK_SIZE;
+
         private readonly List<byte[]> _chunks = new List<byte[]>();
         private long _length = 0;
         private long _position = 0;
@@ -140,6 +152,7 @@ public override long Position
         /// <exception cref="NotSupportedException">Thrown if stream is in read mode.</exception>
         /// <exception cref="ArgumentNullException">Thrown if buffer is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException">Thrown if offset or count is negative or exceeds buffer bounds.</exception>
+        /// <exception cref="IOException">Thrown if the write would exceed the maximum supported stream size (approximately 175TB).</exception>
         public override void Write(byte[] buffer, int offset, int count)
         {
             ThrowIfDisposed();
@@ -156,6 +169,10 @@ public override void Write(byte[] buffer, int offset, int count)
             if (offset + count > buffer.Length)
                 throw new ArgumentException("Offset and count exceed buffer bounds");
 
+            // Check for overflow before writing - prevents chunk index overflow for extremely large streams
+            if (_length > MAX_STREAM_SIZE - count)
+                throw new IOException($"Write would exceed maximum supported stream size of {MAX_STREAM_SIZE} bytes (approximately 175TB).");
+
             int remaining = count;
             int sourceOffset = offset;
 
@@ -194,11 +211,11 @@ public override void Write(byte[] buffer, int offset, int count)
         /// <remarks>
         /// Delegates to synchronous <see cref="Write"/> as ArrayPool operations are fast and don't benefit from async.
         /// </remarks>
-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
             Write(buffer, offset, count);
-            await Task.CompletedTask.ConfigureAwait(false);
+            return Task.CompletedTask;
         }
 
         /// <summary>
@@ -267,10 +284,10 @@ public override int Read(byte[] buffer, int offset, int count)
         /// <remarks>
         /// Delegates to synchronous <see cref="Read"/> as buffer operations are fast and don't benefit from async.
         /// </remarks>
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            return await Task.FromResult(Read(buffer, offset, count)).ConfigureAwait(false);
+            return Task.FromResult(Read(buffer, offset, count));
         }
 
         /// <summary>

sdk/src/Services/S3/Custom/Transfer/Internal/ChunkedPartDataSource.cs

@@ -45,7 +45,7 @@ namespace Amazon.S3.Transfer.Internal
     /// var dataSource = new ChunkedPartDataSource(partNumber, chunkedStream);
     /// 
     /// // Added to PartBufferManager
-    /// _partBufferManager.AddBuffer(dataSource);
+    /// _partBufferManager.AddDataSource(dataSource);
     /// 
     /// // Consumer reads sequentially
     /// await dataSource.ReadAsync(buffer, offset, count, ct);
@@ -79,6 +79,7 @@ internal class ChunkedPartDataSource : IPartDataSource
         /// <param name="partNumber">The part number for ordering.</param>
         /// <param name="stream">The ChunkedBufferStream containing the buffered part data. Must be in read mode.</param>
         /// <exception cref="ArgumentNullException">Thrown if stream is null.</exception>
+        /// <exception cref="InvalidOperationException">Thrown if the stream is not in read mode (CanRead is false).</exception>
         public ChunkedPartDataSource(int partNumber, ChunkedBufferStream stream)
         {
             PartNumber = partNumber;
@@ -100,8 +101,12 @@ public ChunkedPartDataSource(int partNumber, ChunkedBufferStream stream)
         /// of bytes read into the buffer. This can be less than the requested count if that many bytes
         /// are not currently available, or zero if the end of the stream is reached.
         /// </returns>
+        /// <exception cref="ObjectDisposedException">Thrown if the object has been disposed.</exception>
         public async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
+            if (_disposed)
+                throw new ObjectDisposedException(nameof(ChunkedPartDataSource));
+            
             return await _stream.ReadAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
         }