Fix MemoryPoolIterator2.CopyTo's block traversal

- This fix prevents large request streams from being corrupted

#234

Author: halter73

src/Microsoft.AspNet.Server.Kestrel/Infrastructure/MemoryPoolIterator2.cs

@@ -442,6 +442,7 @@ public MemoryPoolIterator2 CopyTo(byte[] array, int offset, int count, out int a
                 else
                 {
                     Buffer.BlockCopy(block.Array, index, array, offset, following);
+                    offset += following;
                     remaining -= following;
                     block = block.Next;
                     index = block.Start;

test/Microsoft.AspNet.Server.Kestrel.FunctionalTests/RequestTests.cs

@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.AspNet.Builder;
+using Microsoft.AspNet.Hosting;
+using Microsoft.AspNet.Http;
+using Microsoft.Dnx.Runtime.Infrastructure;
+using Microsoft.Extensions.Configuration;
+using Xunit;
+
+namespace Microsoft.AspNet.Server.Kestrel.FunctionalTests
+{
+    public class RequestTests
+    {
+        [Fact]
+        public async Task LargeUpload()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "server.urls", "http://localhost:8791/" }
+                })
+                .Build();
+
+            var hostBuilder = new WebHostBuilder(CallContextServiceLocator.Locator.ServiceProvider, config);
+            hostBuilder.UseServer("Microsoft.AspNet.Server.Kestrel");
+            hostBuilder.UseStartup(app =>
+            {
+                app.Run(async context =>
+                {
+                    // Read the full request body
+                    var total = 0;
+                    var bytes = new byte[1024];
+                    var count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length);
+                    while (count > 0)
+                    {
+                        for (int i = 0; i < count; i++)
+                        {
+                            Assert.Equal(total % 256, bytes[i]);
+                            total++;
+                        }
+                        count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length);
+                    }
+
+                    await context.Response.WriteAsync(total.ToString(CultureInfo.InvariantCulture));
+                });
+            });            
+
+            using (var app = hostBuilder.Build().Start())
+            {
+                using (var client = new HttpClient())
+                {
+                    var bytes = new byte[1024 * 1024];
+                    for (int i = 0; i < bytes.Length; i++)
+                    {
+                        bytes[i] = (byte)i;
+                    }
+                        
+                    var response = await client.PostAsync("http://localhost:8791/", new ByteArrayContent(bytes));
+                    response.EnsureSuccessStatusCode();
+                    var sizeString = await response.Content.ReadAsStringAsync();
+                    Assert.Equal(sizeString, bytes.Length.ToString(CultureInfo.InvariantCulture));
+                }
+            }
+        }
+    }
+}

test/Microsoft.AspNet.Server.KestrelTests/MemoryPoolBlock2Tests.cs

@@ -117,6 +117,41 @@ public void AddDoesNotAdvanceAtEndOfCurrentBlock()
             }
         }
 
+        [Fact]
+        public void CopyToCorrectlyTraversesBlocks()
+        {
+            using (var pool = new MemoryPool2())
+            {
+                var block1 = pool.Lease(128);
+                var block2 = block1.Next = pool.Lease(128);
+
+                for (int i = 0; i < 128; i++)
+                {
+                    block1.Array[block1.End++] = (byte)i;
+                }
+                for (int i = 128; i < 256; i++)
+                {
+                    block2.Array[block2.End++] = (byte)i;
+                }
+
+                var beginIterator = block1.GetIterator();
+                
+                var array = new byte[256];
+                int actual;
+                var endIterator = beginIterator.CopyTo(array, 0, 256, out actual);
+
+                Assert.Equal(256, actual);
+
+                for (int i = 0; i < 256; i++)
+                {
+                    Assert.Equal(i, array[i]);
+                }
+
+                endIterator.CopyTo(array, 0, 256, out actual);
+                Assert.Equal(0, actual);
+            }
+        }
+
         private void AssertIterator(MemoryPoolIterator2 iter, MemoryPoolBlock2 block, int index)
         {
             Assert.Same(block, iter.Block);