# This is a combination of 2 commits.

# This is the 1st commit message:

#539 Implement request body size limit

# The commit message #2 will be skipped:

# Check exception messages

Author: Tratcher

src/Microsoft.AspNetCore.Server.HttpSys/FeatureContext.cs

@@ -28,7 +28,8 @@ internal class FeatureContext :
         IHttpRequestLifetimeFeature,
         IHttpAuthenticationFeature,
         IHttpUpgradeFeature,
-        IHttpRequestIdentifierFeature
+        IHttpRequestIdentifierFeature,
+        IHttpMaxRequestBodySizeFeature
     {
         private RequestContext _requestContext;
         private IFeatureCollection _features;
@@ -62,11 +63,11 @@ internal class FeatureContext :
         private bool _responseStarted;
         private bool _completed;
 
-        internal FeatureContext(RequestContext requestContext, bool enableResponseCaching)
+        internal FeatureContext(RequestContext requestContext)
         {
             _requestContext = requestContext;
             _features = new FeatureCollection(new StandardFeatureCollection(this));
-            _enableResponseCaching = enableResponseCaching;
+            _enableResponseCaching = _requestContext.Server.Options.EnableResponseCaching;
 
             // Pre-initialize any fields that are not lazy at the lower level.
             _requestHeaders = Request.Headers;
@@ -78,7 +79,7 @@ internal FeatureContext(RequestContext requestContext, bool enableResponseCachin
             _scheme = Request.Scheme;
             _user = _requestContext.User;
 
-            _responseStream = new ResponseStream(requestContext.Response.Body, OnStart);
+            _responseStream = new ResponseStream(requestContext.Response.Body, OnResponseStart);
             _responseHeaders = Response.Headers;
         }
 
@@ -405,7 +406,7 @@ int IHttpResponseFeature.StatusCode
 
         async Task IHttpSendFileFeature.SendFileAsync(string path, long offset, long? length, CancellationToken cancellation)
         {
-            await OnStart();
+            await OnResponseStart();
             await Response.SendFileAsync(path, offset, length, cancellation);
         }
 
@@ -433,7 +434,7 @@ CancellationToken IHttpRequestLifetimeFeature.RequestAborted
 
         async Task<Stream> IHttpUpgradeFeature.UpgradeAsync()
         {
-            await OnStart();
+            await OnResponseStart();
             return await _requestContext.UpgradeAsync();
         }
 
@@ -463,7 +464,15 @@ string IHttpRequestIdentifierFeature.TraceIdentifier
             }
         }
 
-        internal async Task OnStart()
+        bool IHttpMaxRequestBodySizeFeature.IsReadOnly => Request.HasRequestBodyStarted;
+
+        long? IHttpMaxRequestBodySizeFeature.MaxRequestBodySize
+        {
+            get => Request.MaxRequestBodySize;
+            set => Request.MaxRequestBodySize = value;
+        }
+
+        internal async Task OnResponseStart()
         {
             if (_responseStarted)
             {

src/Microsoft.AspNetCore.Server.HttpSys/HttpSysOptions.cs

@@ -2,19 +2,24 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.AspNetCore.Http.Features;
 
 namespace Microsoft.AspNetCore.Server.HttpSys
 {
     public class HttpSysOptions
     {
         private const long DefaultRequestQueueLength = 1000; // Http.sys default.
         internal static readonly int DefaultMaxAccepts = 5 * Environment.ProcessorCount;
+        // Matches the default maxAllowedContentLength in IIS (~28.6 MB)
+        // https://www.iis.net/configreference/system.webserver/security/requestfiltering/requestlimits#005
+        private const long DefaultMaxRequestBodySize = 30000000;
 
         // The native request queue
         private long _requestQueueLength = DefaultRequestQueueLength;
         private long? _maxConnections;
         private RequestQueue _requestQueue;
         private UrlGroup _urlGroup;
+        private long? _maxRequestBodySize = DefaultMaxRequestBodySize;
 
         public HttpSysOptions()
         {
@@ -104,6 +109,28 @@ public long RequestQueueLimit
             }
         }
 
+        /// <summary>
+        /// Gets or sets the maximum allowed size of any request body in bytes.
+        /// When set to null, the maximum request body size is unlimited.
+        /// This limit has no effect on upgraded connections which are always unlimited.
+        /// This can be overridden per-request via <see cref="IHttpMaxRequestBodySizeFeature"/>.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to 30,000,000 bytes, which is approximately 28.6MB.
+        /// </remarks>
+        public long? MaxRequestBodySize
+        {
+            get => _maxRequestBodySize;
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value, string.Empty);
+                }
+                _maxRequestBodySize = value;
+            }
+        }
+
         internal void Apply(UrlGroup urlGroup, RequestQueue requestQueue)
         {
             _urlGroup = urlGroup;

src/Microsoft.AspNetCore.Server.HttpSys/MessagePump.cs

@@ -56,14 +56,11 @@ public MessagePump(IOptions<HttpSysOptions> options, ILoggerFactory loggerFactor
 
             _processRequest = new Action<object>(ProcessRequestAsync);
             _maxAccepts = _options.MaxAccepts;
-            EnableResponseCaching = _options.EnableResponseCaching;
             _shutdownSignal = new TaskCompletionSource<object>();
         }
 
         internal HttpSysListener Listener { get; }
 
-        internal bool EnableResponseCaching { get; set; }
-
         public IFeatureCollection Features { get; }
 
         public Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
@@ -199,12 +196,12 @@ private async void ProcessRequestAsync(object requestContextObj)
                 Interlocked.Increment(ref _outstandingRequests);
                 try
                 {
-                    var featureContext = new FeatureContext(requestContext, EnableResponseCaching);
+                    var featureContext = new FeatureContext(requestContext);
                     context = _application.CreateContext(featureContext.Features);
                     try
                     {
                         await _application.ProcessRequestAsync(context).SupressContext();
-                        await featureContext.OnStart();
+                        await featureContext.OnResponseStart();
                         requestContext.Dispose();
                         _application.DisposeContext(context, null);
                     }

src/Microsoft.AspNetCore.Server.HttpSys/RequestProcessing/Request.cs

@@ -24,7 +24,7 @@ internal sealed class Request
 
         private BoundaryType _contentBoundaryType;
         private long? _contentLength;
-        private Stream _nativeStream;
+        private RequestStream _nativeStream;
 
         private SocketAddress _localEndPoint;
         private SocketAddress _remoteEndPoint;
@@ -143,15 +143,32 @@ public long? ContentLength
 
         public string Method { get; }
 
-        public Stream Body
+        public Stream Body => EnsureRequestStream() ?? Stream.Null;
+
+        private RequestStream EnsureRequestStream()
         {
-            get
+            if (_nativeStream == null && HasEntityBody)
+            {
+                _nativeStream = new RequestStream(RequestContext)
+                {
+                    MaxSize = RequestContext.Server.Options.MaxRequestBodySize
+                };
+            }
+            return _nativeStream;
+        }
+
+        public bool HasRequestBodyStarted => _nativeStream?.HasStarted ?? false;
+
+        public long? MaxRequestBodySize
+        {
+            get => EnsureRequestStream()?.MaxSize;
+            set
             {
-                if (_nativeStream == null)
+                EnsureRequestStream();
+                if (_nativeStream != null)
                 {
-                    _nativeStream = HasEntityBody ? new RequestStream(RequestContext) : Stream.Null;
+                    _nativeStream.MaxSize = value;
                 }
-                return _nativeStream;
             }
         }
 
@@ -319,10 +336,11 @@ private void CheckDisposed()
 
         internal void SwitchToOpaqueMode()
         {
-            if (_nativeStream == null || _nativeStream == Stream.Null)
+            if (_nativeStream == null)
             {
                 _nativeStream = new RequestStream(RequestContext);
             }
+            _nativeStream.SwitchToOpaqueMode();
         }
     }
 }