Force 8-byte alignment on HTTP_REQUEST buffer

moozzyk · moozzyk · commit 1b43c5ec5be2 · 2016-06-15T16:09:49.000-07:00
Addresses #126
diff --git a/src/Microsoft.Net.Http.Server/NativeInterop/UnsafeNativeMethods.cs b/src/Microsoft.Net.Http.Server/NativeInterop/UnsafeNativeMethods.cs
@@ -1049,12 +1049,13 @@ internal static bool Supported
 
             // Server API
 
-            internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknownHeaders, byte[] memoryBlob, IntPtr originalAddress)
+            internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknownHeaders, byte[] memoryBlob,
+                int requestOffset, IntPtr originalAddress)
             {
                 // Return value.
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;
+                    HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);
                     long fixup = pMemoryBlob - (byte*)originalAddress;
                     int index;
 
@@ -1064,7 +1065,7 @@ internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknown
                         HTTP_UNKNOWN_HEADER* pUnknownHeader = (HTTP_UNKNOWN_HEADER*)(fixup + (byte*)request->Headers.pUnknownHeaders);
                         for (index = 0; index < request->Headers.UnknownHeaderCount; index++)
                         {
-                            // For unknown headers, when header value is empty, RawValueLength will be 0 and 
+                            // For unknown headers, when header value is empty, RawValueLength will be 0 and
                             // pRawValue will be null.
                             if (pUnknownHeader->pName != null && pUnknownHeader->NameLength > 0)
                             {
@@ -1093,7 +1094,7 @@ private static string GetKnownHeader(HTTP_REQUEST* request, long fixup, int head
                 string header = null;
 
                 HTTP_KNOWN_HEADER* pKnownHeader = (&request->Headers.KnownHeaders) + headerIndex;
-                // For known headers, when header value is empty, RawValueLength will be 0 and 
+                // For known headers, when header value is empty, RawValueLength will be 0 and
                 // pRawValue will point to empty string ("\0")
                 if (pKnownHeader->pRawValue != null)
                 {
@@ -1103,11 +1104,12 @@ private static string GetKnownHeader(HTTP_REQUEST* request, long fixup, int head
                 return header;
             }
 
-            internal static string GetKnownHeader(byte[] memoryBlob, IntPtr originalAddress, int headerIndex)
+            internal static string GetKnownHeader(byte[] memoryBlob, int requestOffset, IntPtr originalAddress, int headerIndex)
             {
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    return GetKnownHeader((HTTP_REQUEST*)pMemoryBlob, pMemoryBlob - (byte*)originalAddress, headerIndex);
+                    return GetKnownHeader(
+                        (HTTP_REQUEST*)(pMemoryBlob + requestOffset), pMemoryBlob - (byte*)originalAddress, headerIndex);
                 }
             }
 
@@ -1127,21 +1129,21 @@ private static unsafe string GetVerb(HTTP_REQUEST* request, long fixup)
                 return verb;
             }
 
-            internal static unsafe string GetVerb(byte[] memoryBlob, IntPtr originalAddress)
+            internal static unsafe string GetVerb(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)
             {
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    return GetVerb((HTTP_REQUEST*)pMemoryBlob, pMemoryBlob - (byte*)originalAddress);
+                    return GetVerb((HTTP_REQUEST*)(pMemoryBlob + requestOffset), pMemoryBlob - (byte*)originalAddress);
                 }
             }
 
-            internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, IntPtr originalAddress)
+            internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)
             {
                 // Return value.
                 HTTP_VERB verb = HTTP_VERB.HttpVerbUnknown;
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;
+                    HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);
                     if ((int)request->Verb > (int)HTTP_VERB.HttpVerbUnparsed && (int)request->Verb < (int)HTTP_VERB.HttpVerbMaximum)
                     {
                         verb = request->Verb;
@@ -1151,13 +1153,14 @@ internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, IntPtr originalAddress
                 return verb;
             }
 
-            internal static uint GetChunks(byte[] memoryBlob, IntPtr originalAddress, ref int dataChunkIndex, ref uint dataChunkOffset, byte[] buffer, int offset, int size)
+            internal static uint GetChunks(byte[] memoryBlob, int requestOffset, IntPtr originalAddress,
+                ref int dataChunkIndex, ref uint dataChunkOffset, byte[] buffer, int offset, int size)
             {
                 // Return value.
                 uint dataRead = 0;
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;
+                    HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);
                     long fixup = pMemoryBlob - (byte*)originalAddress;
 
                     if (request->EntityChunkCount > 0 && dataChunkIndex < request->EntityChunkCount && dataChunkIndex != -1)
@@ -1205,30 +1208,30 @@ internal static uint GetChunks(byte[] memoryBlob, IntPtr originalAddress, ref in
                 return dataRead;
             }
 
-            internal static SocketAddress GetRemoteEndPoint(byte[] memoryBlob, IntPtr originalAddress)
+            internal static SocketAddress GetRemoteEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)
             {
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;
-                    return GetEndPoint(memoryBlob, originalAddress, (byte*)request->Address.pRemoteAddress);
+                    HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);
+                    return GetEndPoint(memoryBlob, requestOffset, originalAddress, (byte*)request->Address.pRemoteAddress);
                 }
             }
 
-            internal static SocketAddress GetLocalEndPoint(byte[] memoryBlob, IntPtr originalAddress)
+            internal static SocketAddress GetLocalEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)
             {
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
-                    HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;
-                    return GetEndPoint(memoryBlob, originalAddress, (byte*)request->Address.pLocalAddress);
+                    HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);
+                    return GetEndPoint(memoryBlob, requestOffset, originalAddress, (byte*)request->Address.pLocalAddress);
                 }
             }
 
-            internal static SocketAddress GetEndPoint(byte[] memoryBlob, IntPtr originalAddress, byte* source)
+            internal static SocketAddress GetEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress, byte* source)
             {
                 fixed (byte* pMemoryBlob = memoryBlob)
                 {
                     IntPtr address = source != null ?
-                        (IntPtr)(pMemoryBlob - (byte*)originalAddress + source) : IntPtr.Zero;
+                        (IntPtr)(pMemoryBlob + requestOffset - (byte*)originalAddress + source) : IntPtr.Zero;
                     return CopyOutAddress(address);
                 }
             }
diff --git a/src/Microsoft.Net.Http.Server/RequestProcessing/NativeRequestContext.cs b/src/Microsoft.Net.Http.Server/RequestProcessing/NativeRequestContext.cs
@@ -31,9 +31,11 @@ namespace Microsoft.Net.Http.Server
     internal unsafe class NativeRequestContext : IDisposable
     {
         private const int DefaultBufferSize = 4096;
+        private const int AlignmentPadding = 8;
         private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* _memoryBlob;
         private IntPtr _originalBlobAddress;
         private byte[] _backingBuffer;
+        private int _offset;
         private SafeNativeOverlapped _nativeOverlapped;
         private AsyncAcceptContext _acceptResult;
 
@@ -80,7 +82,15 @@ internal uint Size
         {
             get
             {
-                return (uint)_backingBuffer.Length;
+                return (uint)_backingBuffer.Length - AlignmentPadding;
+            }
+        }
+
+        internal int Offset
+        {
+            get
+            {
+                return _offset;
             }
         }
 
@@ -89,7 +99,7 @@ internal IntPtr OriginalBlobAddress
             get
             {
                 UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* blob = _memoryBlob;
-                return (blob == null ? _originalBlobAddress : (IntPtr)blob);
+                return blob == null ? _originalBlobAddress : (IntPtr)blob;
             }
         }
 
@@ -155,28 +165,31 @@ private void UnsetBlob()
 
         private void SetBuffer(int size)
         {
-            _backingBuffer = size == 0 ? null : new byte[size];
+            Debug.Assert(size != 0, "unexpected size");
+
+            _backingBuffer = new byte[size + AlignmentPadding];
         }
 
         private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* Allocate(uint size)
         {
-            uint newSize = size != 0 ? size : RequestBuffer == null ? DefaultBufferSize : Size;
             // We can't reuse overlapped objects
             if (_nativeOverlapped != null)
             {
                 SafeNativeOverlapped nativeOverlapped = _nativeOverlapped;
                 _nativeOverlapped = null;
                 nativeOverlapped.Dispose();
             }
-            if (_nativeOverlapped == null)
-            {
-                SetBuffer(checked((int)newSize));
-                var boundHandle = _acceptResult.Server.BoundHandle;
-                _nativeOverlapped = new SafeNativeOverlapped(boundHandle,
-                    boundHandle.AllocateNativeOverlapped(AsyncAcceptContext.IOCallback, _acceptResult, RequestBuffer));
-                return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*)Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);
-            }
-            return RequestBlob;
+
+            uint newSize = size != 0 ? size : RequestBuffer == null ? DefaultBufferSize : Size;
+            SetBuffer(checked((int)newSize));
+            var boundHandle = _acceptResult.Server.BoundHandle;
+            _nativeOverlapped = new SafeNativeOverlapped(boundHandle,
+                boundHandle.AllocateNativeOverlapped(AsyncAcceptContext.IOCallback, _acceptResult, RequestBuffer));
+
+            var requestAddress = Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);
+            _offset = (int)(requestAddress.ToInt64() & 0x07);
+
+            return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*)(requestAddress + _offset);
         }
 
         internal void Reset(ulong requestId, uint size)
diff --git a/src/Microsoft.Net.Http.Server/RequestProcessing/Request.cs b/src/Microsoft.Net.Http.Server/RequestProcessing/Request.cs
@@ -141,7 +141,7 @@ internal unsafe Request(RequestContext httpContext, NativeRequestContext memoryB
                 _httpVersion = new Version(major, minor);
             }
 
-            _httpMethod = UnsafeNclNativeMethods.HttpApi.GetVerb(RequestBuffer, OriginalBlobAddress);
+            _httpMethod = UnsafeNclNativeMethods.HttpApi.GetVerb(RequestBuffer, RequestOffset, OriginalBlobAddress);
             _headers = new HeaderCollection(new RequestHeaders(_nativeRequestContext));
 
             var requestV2 = (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST_V2*)memoryBlob.RequestBlob;
@@ -190,6 +190,15 @@ internal byte[] RequestBuffer
             }
         }
 
+        internal int RequestOffset
+        {
+            get
+            {
+                CheckDisposed();
+                return _nativeRequestContext.Offset;
+            }
+        }
+
         internal IntPtr OriginalBlobAddress
         {
             get
@@ -304,7 +313,7 @@ public string RawUrl
                 return _rawUrl;
             }
         }
-        
+
         public Version ProtocolVersion
         {
             get
@@ -329,7 +338,7 @@ private SocketAddress RemoteEndPoint
             {
                 if (_remoteEndPoint == null)
                 {
-                    _remoteEndPoint = UnsafeNclNativeMethods.HttpApi.GetRemoteEndPoint(RequestBuffer, OriginalBlobAddress);
+                    _remoteEndPoint = UnsafeNclNativeMethods.HttpApi.GetRemoteEndPoint(RequestBuffer, RequestOffset, OriginalBlobAddress);
                 }
 
                 return _remoteEndPoint;
@@ -342,7 +351,7 @@ private SocketAddress LocalEndPoint
             {
                 if (_localEndPoint == null)
                 {
-                    _localEndPoint = UnsafeNclNativeMethods.HttpApi.GetLocalEndPoint(RequestBuffer, OriginalBlobAddress);
+                    _localEndPoint = UnsafeNclNativeMethods.HttpApi.GetLocalEndPoint(RequestBuffer, RequestOffset, OriginalBlobAddress);
                 }
 
                 return _localEndPoint;
@@ -406,7 +415,7 @@ internal ClaimsPrincipal User
 
         internal UnsafeNclNativeMethods.HttpApi.HTTP_VERB GetKnownMethod()
         {
-            return UnsafeNclNativeMethods.HttpApi.GetKnownVerb(RequestBuffer, OriginalBlobAddress);
+            return UnsafeNclNativeMethods.HttpApi.GetKnownVerb(RequestBuffer, RequestOffset, OriginalBlobAddress);
         }
 
         // Populates the client certificate.  The result may be null if there is no client cert.
diff --git a/src/Microsoft.Net.Http.Server/RequestProcessing/RequestHeaders.cs b/src/Microsoft.Net.Http.Server/RequestProcessing/RequestHeaders.cs
@@ -86,13 +86,13 @@ StringValues IDictionary<string, StringValues>.this[string key]
         private string GetKnownHeader(HttpSysRequestHeader header)
         {
             return UnsafeNclNativeMethods.HttpApi.GetKnownHeader(_requestMemoryBlob.RequestBuffer,
-                _requestMemoryBlob.OriginalBlobAddress, (int)header);
+                _requestMemoryBlob.Offset, _requestMemoryBlob.OriginalBlobAddress, (int)header);
         }
 
         private void GetUnknownHeaders(IDictionary<string, StringValues> extra)
         {
             UnsafeNclNativeMethods.HttpApi.GetUnknownHeaders(extra, _requestMemoryBlob.RequestBuffer,
-                _requestMemoryBlob.OriginalBlobAddress);
+                _requestMemoryBlob.Offset, _requestMemoryBlob.OriginalBlobAddress);
         }
 
         void IDictionary<string, StringValues>.Add(string key, StringValues value)
diff --git a/src/Microsoft.Net.Http.Server/RequestProcessing/RequestStream.cs b/src/Microsoft.Net.Http.Server/RequestProcessing/RequestStream.cs
@@ -147,7 +147,9 @@ public override unsafe int Read([In, Out] byte[] buffer, int offset, int size)
 
             if (_dataChunkIndex != -1)
             {
-                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
+                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer,
+                    _requestContext.Request.RequestOffset, _requestContext.Request.OriginalBlobAddress,
+                    ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
             }
 
             if (_dataChunkIndex == -1 && dataRead < size)
@@ -223,7 +225,9 @@ public override unsafe IAsyncResult BeginRead(byte[] buffer, int offset, int siz
             uint dataRead = 0;
             if (_dataChunkIndex != -1)
             {
-                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
+                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.RequestOffset,
+                    _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
+
                 if (_dataChunkIndex != -1 && dataRead == size)
                 {
                     asyncResult = new RequestStreamAsyncResult(this, state, callback, buffer, offset, 0);
@@ -339,15 +343,16 @@ public override unsafe Task<int> ReadAsync(byte[] buffer, int offset, int size,
             uint dataRead = 0;
             if (_dataChunkIndex != -1)
             {
-                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
+                dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.RequestOffset,
+                    _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);
                 if (_dataChunkIndex != -1 && dataRead == size)
                 {
                     UpdateAfterRead(UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS, dataRead);
                     // TODO: Verbose log #dataRead
                     return Task.FromResult<int>((int)dataRead);
                 }
             }
-            
+
             if (_dataChunkIndex == -1 && dataRead < size)
             {
                 uint statusCode = 0;
diff --git a/src/Microsoft.Net.Http.Server/WebListener.cs b/src/Microsoft.Net.Http.Server/WebListener.cs
@@ -890,7 +890,7 @@ private unsafe ChannelBinding GetChannelBindingFromTls(ulong connectionId)
                 blob = new byte[size];
                 fixed (byte* blobPtr = blob)
                 {
-                    // Http.sys team: ServiceName will always be null if 
+                    // Http.sys team: ServiceName will always be null if
                     // HTTP_RECEIVE_SECURE_CHANNEL_TOKEN flag is set.
                     statusCode = UnsafeNclNativeMethods.HttpApi.HttpReceiveClientCertificate(
                         RequestQueueHandle,

Original file line number	Diff line number	Diff line change
`@@ -1049,12 +1049,13 @@ internal static bool Supported`
`1049`	`1049`
`1050`	`1050`	`// Server API`
`1051`	`1051`
`1052`		`- internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknownHeaders, byte[] memoryBlob, IntPtr originalAddress)`
	`1052`	`+ internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknownHeaders, byte[] memoryBlob,`
	`1053`	`+ int requestOffset, IntPtr originalAddress)`
`1053`	`1054`	`{`
`1054`	`1055`	`// Return value.`
`1055`	`1056`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1056`	`1057`	`{`
`1057`		`- HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;`
	`1058`	`+ HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);`
`1058`	`1059`	`long fixup = pMemoryBlob - (byte*)originalAddress;`
`1059`	`1060`	`int index;`
`1060`	`1061`
`@@ -1064,7 +1065,7 @@ internal static void GetUnknownHeaders(IDictionary<string, StringValues> unknown`
`1064`	`1065`	`HTTP_UNKNOWN_HEADER* pUnknownHeader = (HTTP_UNKNOWN_HEADER)(fixup + (byte)request->Headers.pUnknownHeaders);`
`1065`	`1066`	`for (index = 0; index < request->Headers.UnknownHeaderCount; index++)`
`1066`	`1067`	`{`
`1067`		`- // For unknown headers, when header value is empty, RawValueLength will be 0 and`
	`1068`	`+ // For unknown headers, when header value is empty, RawValueLength will be 0 and`
`1068`	`1069`	`// pRawValue will be null.`
`1069`	`1070`	`if (pUnknownHeader->pName != null && pUnknownHeader->NameLength > 0)`
`1070`	`1071`	`{`
`@@ -1093,7 +1094,7 @@ private static string GetKnownHeader(HTTP_REQUEST* request, long fixup, int head`
`1093`	`1094`	`string header = null;`
`1094`	`1095`
`1095`	`1096`	`HTTP_KNOWN_HEADER* pKnownHeader = (&request->Headers.KnownHeaders) + headerIndex;`
`1096`		`- // For known headers, when header value is empty, RawValueLength will be 0 and`
	`1097`	`+ // For known headers, when header value is empty, RawValueLength will be 0 and`
`1097`	`1098`	`// pRawValue will point to empty string ("\0")`
`1098`	`1099`	`if (pKnownHeader->pRawValue != null)`
`1099`	`1100`	`{`
`@@ -1103,11 +1104,12 @@ private static string GetKnownHeader(HTTP_REQUEST* request, long fixup, int head`
`1103`	`1104`	`return header;`
`1104`	`1105`	`}`
`1105`	`1106`
`1106`		`- internal static string GetKnownHeader(byte[] memoryBlob, IntPtr originalAddress, int headerIndex)`
	`1107`	`+ internal static string GetKnownHeader(byte[] memoryBlob, int requestOffset, IntPtr originalAddress, int headerIndex)`
`1107`	`1108`	`{`
`1108`	`1109`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1109`	`1110`	`{`
`1110`		`- return GetKnownHeader((HTTP_REQUEST)pMemoryBlob, pMemoryBlob - (byte)originalAddress, headerIndex);`
	`1111`	`+ return GetKnownHeader(`
	`1112`	`+ (HTTP_REQUEST)(pMemoryBlob + requestOffset), pMemoryBlob - (byte)originalAddress, headerIndex);`
`1111`	`1113`	`}`
`1112`	`1114`	`}`
`1113`	`1115`
`@@ -1127,21 +1129,21 @@ private static unsafe string GetVerb(HTTP_REQUEST* request, long fixup)`
`1127`	`1129`	`return verb;`
`1128`	`1130`	`}`
`1129`	`1131`
`1130`		`- internal static unsafe string GetVerb(byte[] memoryBlob, IntPtr originalAddress)`
	`1132`	`+ internal static unsafe string GetVerb(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)`
`1131`	`1133`	`{`
`1132`	`1134`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1133`	`1135`	`{`
`1134`		`- return GetVerb((HTTP_REQUEST)pMemoryBlob, pMemoryBlob - (byte)originalAddress);`
	`1136`	`+ return GetVerb((HTTP_REQUEST)(pMemoryBlob + requestOffset), pMemoryBlob - (byte)originalAddress);`
`1135`	`1137`	`}`
`1136`	`1138`	`}`
`1137`	`1139`
`1138`		`- internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, IntPtr originalAddress)`
	`1140`	`+ internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)`
`1139`	`1141`	`{`
`1140`	`1142`	`// Return value.`
`1141`	`1143`	`HTTP_VERB verb = HTTP_VERB.HttpVerbUnknown;`
`1142`	`1144`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1143`	`1145`	`{`
`1144`		`- HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;`
	`1146`	`+ HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);`
`1145`	`1147`	`if ((int)request->Verb > (int)HTTP_VERB.HttpVerbUnparsed && (int)request->Verb < (int)HTTP_VERB.HttpVerbMaximum)`
`1146`	`1148`	`{`
`1147`	`1149`	`verb = request->Verb;`
`@@ -1151,13 +1153,14 @@ internal static HTTP_VERB GetKnownVerb(byte[] memoryBlob, IntPtr originalAddress`
`1151`	`1153`	`return verb;`
`1152`	`1154`	`}`
`1153`	`1155`
`1154`		`- internal static uint GetChunks(byte[] memoryBlob, IntPtr originalAddress, ref int dataChunkIndex, ref uint dataChunkOffset, byte[] buffer, int offset, int size)`
	`1156`	`+ internal static uint GetChunks(byte[] memoryBlob, int requestOffset, IntPtr originalAddress,`
	`1157`	`+ ref int dataChunkIndex, ref uint dataChunkOffset, byte[] buffer, int offset, int size)`
`1155`	`1158`	`{`
`1156`	`1159`	`// Return value.`
`1157`	`1160`	`uint dataRead = 0;`
`1158`	`1161`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1159`	`1162`	`{`
`1160`		`- HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;`
	`1163`	`+ HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);`
`1161`	`1164`	`long fixup = pMemoryBlob - (byte*)originalAddress;`
`1162`	`1165`
`1163`	`1166`	`if (request->EntityChunkCount > 0 && dataChunkIndex < request->EntityChunkCount && dataChunkIndex != -1)`
`@@ -1205,30 +1208,30 @@ internal static uint GetChunks(byte[] memoryBlob, IntPtr originalAddress, ref in`
`1205`	`1208`	`return dataRead;`
`1206`	`1209`	`}`
`1207`	`1210`
`1208`		`- internal static SocketAddress GetRemoteEndPoint(byte[] memoryBlob, IntPtr originalAddress)`
	`1211`	`+ internal static SocketAddress GetRemoteEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)`
`1209`	`1212`	`{`
`1210`	`1213`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1211`	`1214`	`{`
`1212`		`- HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;`
`1213`		`- return GetEndPoint(memoryBlob, originalAddress, (byte*)request->Address.pRemoteAddress);`
	`1215`	`+ HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);`
	`1216`	`+ return GetEndPoint(memoryBlob, requestOffset, originalAddress, (byte*)request->Address.pRemoteAddress);`
`1214`	`1217`	`}`
`1215`	`1218`	`}`
`1216`	`1219`
`1217`		`- internal static SocketAddress GetLocalEndPoint(byte[] memoryBlob, IntPtr originalAddress)`
	`1220`	`+ internal static SocketAddress GetLocalEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress)`
`1218`	`1221`	`{`
`1219`	`1222`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1220`	`1223`	`{`
`1221`		`- HTTP_REQUEST* request = (HTTP_REQUEST*)pMemoryBlob;`
`1222`		`- return GetEndPoint(memoryBlob, originalAddress, (byte*)request->Address.pLocalAddress);`
	`1224`	`+ HTTP_REQUEST* request = (HTTP_REQUEST*)(pMemoryBlob + requestOffset);`
	`1225`	`+ return GetEndPoint(memoryBlob, requestOffset, originalAddress, (byte*)request->Address.pLocalAddress);`
`1223`	`1226`	`}`
`1224`	`1227`	`}`
`1225`	`1228`
`1226`		`- internal static SocketAddress GetEndPoint(byte[] memoryBlob, IntPtr originalAddress, byte* source)`
	`1229`	`+ internal static SocketAddress GetEndPoint(byte[] memoryBlob, int requestOffset, IntPtr originalAddress, byte* source)`
`1227`	`1230`	`{`
`1228`	`1231`	`fixed (byte* pMemoryBlob = memoryBlob)`
`1229`	`1232`	`{`
`1230`	`1233`	`IntPtr address = source != null ?`
`1231`		`- (IntPtr)(pMemoryBlob - (byte*)originalAddress + source) : IntPtr.Zero;`
	`1234`	`+ (IntPtr)(pMemoryBlob + requestOffset - (byte*)originalAddress + source) : IntPtr.Zero;`
`1232`	`1235`	`return CopyOutAddress(address);`
`1233`	`1236`	`}`
`1234`	`1237`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,11 @@ namespace Microsoft.Net.Http.Server`
`31`	`31`	`internal unsafe class NativeRequestContext : IDisposable`
`32`	`32`	`{`
`33`	`33`	`private const int DefaultBufferSize = 4096;`
	`34`	`+ private const int AlignmentPadding = 8;`
`34`	`35`	`private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* _memoryBlob;`
`35`	`36`	`private IntPtr _originalBlobAddress;`
`36`	`37`	`private byte[] _backingBuffer;`
	`38`	`+ private int _offset;`
`37`	`39`	`private SafeNativeOverlapped _nativeOverlapped;`
`38`	`40`	`private AsyncAcceptContext _acceptResult;`
`39`	`41`
`@@ -80,7 +82,15 @@ internal uint Size`
`80`	`82`	`{`
`81`	`83`	`get`
`82`	`84`	`{`
`83`		`- return (uint)_backingBuffer.Length;`
	`85`	`+ return (uint)_backingBuffer.Length - AlignmentPadding;`
	`86`	`+ }`
	`87`	`+ }`
	`88`	`+`
	`89`	`+ internal int Offset`
	`90`	`+ {`
	`91`	`+ get`
	`92`	`+ {`
	`93`	`+ return _offset;`
`84`	`94`	`}`
`85`	`95`	`}`
`86`	`96`
`@@ -89,7 +99,7 @@ internal IntPtr OriginalBlobAddress`
`89`	`99`	`get`
`90`	`100`	`{`
`91`	`101`	`UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* blob = _memoryBlob;`
`92`		`- return (blob == null ? _originalBlobAddress : (IntPtr)blob);`
	`102`	`+ return blob == null ? _originalBlobAddress : (IntPtr)blob;`
`93`	`103`	`}`
`94`	`104`	`}`
`95`	`105`
`@@ -155,28 +165,31 @@ private void UnsetBlob()`
`155`	`165`
`156`	`166`	`private void SetBuffer(int size)`
`157`	`167`	`{`
`158`		`- _backingBuffer = size == 0 ? null : new byte[size];`
	`168`	`+ Debug.Assert(size != 0, "unexpected size");`
	`169`	`+`
	`170`	`+ _backingBuffer = new byte[size + AlignmentPadding];`
`159`	`171`	`}`
`160`	`172`
`161`	`173`	`private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* Allocate(uint size)`
`162`	`174`	`{`
`163`		`- uint newSize = size != 0 ? size : RequestBuffer == null ? DefaultBufferSize : Size;`
`164`	`175`	`// We can't reuse overlapped objects`
`165`	`176`	`if (_nativeOverlapped != null)`
`166`	`177`	`{`
`167`	`178`	`SafeNativeOverlapped nativeOverlapped = _nativeOverlapped;`
`168`	`179`	`_nativeOverlapped = null;`
`169`	`180`	`nativeOverlapped.Dispose();`
`170`	`181`	`}`
`171`		`- if (_nativeOverlapped == null)`
`172`		`- {`
`173`		`- SetBuffer(checked((int)newSize));`
`174`		`- var boundHandle = _acceptResult.Server.BoundHandle;`
`175`		`- _nativeOverlapped = new SafeNativeOverlapped(boundHandle,`
`176`		`- boundHandle.AllocateNativeOverlapped(AsyncAcceptContext.IOCallback, _acceptResult, RequestBuffer));`
`177`		`- return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*)Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);`
`178`		`- }`
`179`		`- return RequestBlob;`
	`182`	`+`
	`183`	`+ uint newSize = size != 0 ? size : RequestBuffer == null ? DefaultBufferSize : Size;`
	`184`	`+ SetBuffer(checked((int)newSize));`
	`185`	`+ var boundHandle = _acceptResult.Server.BoundHandle;`
	`186`	`+ _nativeOverlapped = new SafeNativeOverlapped(boundHandle,`
	`187`	`+ boundHandle.AllocateNativeOverlapped(AsyncAcceptContext.IOCallback, _acceptResult, RequestBuffer));`
	`188`	`+`
	`189`	`+ var requestAddress = Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);`
	`190`	`+ _offset = (int)(requestAddress.ToInt64() & 0x07);`
	`191`	`+`
	`192`	`+ return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*)(requestAddress + _offset);`
`180`	`193`	`}`
`181`	`194`
`182`	`195`	`internal void Reset(ulong requestId, uint size)`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ internal unsafe Request(RequestContext httpContext, NativeRequestContext memoryB`
`141`	`141`	`_httpVersion = new Version(major, minor);`
`142`	`142`	`}`
`143`	`143`
`144`		`- _httpMethod = UnsafeNclNativeMethods.HttpApi.GetVerb(RequestBuffer, OriginalBlobAddress);`
	`144`	`+ _httpMethod = UnsafeNclNativeMethods.HttpApi.GetVerb(RequestBuffer, RequestOffset, OriginalBlobAddress);`
`145`	`145`	`_headers = new HeaderCollection(new RequestHeaders(_nativeRequestContext));`
`146`	`146`
`147`	`147`	`var requestV2 = (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST_V2*)memoryBlob.RequestBlob;`
`@@ -190,6 +190,15 @@ internal byte[] RequestBuffer`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
	`193`	`+ internal int RequestOffset`
	`194`	`+ {`
	`195`	`+ get`
	`196`	`+ {`
	`197`	`+ CheckDisposed();`
	`198`	`+ return _nativeRequestContext.Offset;`
	`199`	`+ }`
	`200`	`+ }`
	`201`	`+`
`193`	`202`	`internal IntPtr OriginalBlobAddress`
`194`	`203`	`{`
`195`	`204`	`get`
`@@ -304,7 +313,7 @@ public string RawUrl`
`304`	`313`	`return _rawUrl;`
`305`	`314`	`}`
`306`	`315`	`}`
`307`		`-`
	`316`	`+`
`308`	`317`	`public Version ProtocolVersion`
`309`	`318`	`{`
`310`	`319`	`get`
`@@ -329,7 +338,7 @@ private SocketAddress RemoteEndPoint`
`329`	`338`	`{`
`330`	`339`	`if (_remoteEndPoint == null)`
`331`	`340`	`{`
`332`		`- _remoteEndPoint = UnsafeNclNativeMethods.HttpApi.GetRemoteEndPoint(RequestBuffer, OriginalBlobAddress);`
	`341`	`+ _remoteEndPoint = UnsafeNclNativeMethods.HttpApi.GetRemoteEndPoint(RequestBuffer, RequestOffset, OriginalBlobAddress);`
`333`	`342`	`}`
`334`	`343`
`335`	`344`	`return _remoteEndPoint;`
`@@ -342,7 +351,7 @@ private SocketAddress LocalEndPoint`
`342`	`351`	`{`
`343`	`352`	`if (_localEndPoint == null)`
`344`	`353`	`{`
`345`		`- _localEndPoint = UnsafeNclNativeMethods.HttpApi.GetLocalEndPoint(RequestBuffer, OriginalBlobAddress);`
	`354`	`+ _localEndPoint = UnsafeNclNativeMethods.HttpApi.GetLocalEndPoint(RequestBuffer, RequestOffset, OriginalBlobAddress);`
`346`	`355`	`}`
`347`	`356`
`348`	`357`	`return _localEndPoint;`
`@@ -406,7 +415,7 @@ internal ClaimsPrincipal User`
`406`	`415`
`407`	`416`	`internal UnsafeNclNativeMethods.HttpApi.HTTP_VERB GetKnownMethod()`
`408`	`417`	`{`
`409`		`- return UnsafeNclNativeMethods.HttpApi.GetKnownVerb(RequestBuffer, OriginalBlobAddress);`
	`418`	`+ return UnsafeNclNativeMethods.HttpApi.GetKnownVerb(RequestBuffer, RequestOffset, OriginalBlobAddress);`
`410`	`419`	`}`
`411`	`420`
`412`	`421`	`// Populates the client certificate. The result may be null if there is no client cert.`
Original file line number	Diff line number	Diff line change
`@@ -86,13 +86,13 @@ StringValues IDictionary<string, StringValues>.this[string key]`
`86`	`86`	`private string GetKnownHeader(HttpSysRequestHeader header)`
`87`	`87`	`{`
`88`	`88`	`return UnsafeNclNativeMethods.HttpApi.GetKnownHeader(_requestMemoryBlob.RequestBuffer,`
`89`		`- _requestMemoryBlob.OriginalBlobAddress, (int)header);`
	`89`	`+ _requestMemoryBlob.Offset, _requestMemoryBlob.OriginalBlobAddress, (int)header);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`private void GetUnknownHeaders(IDictionary<string, StringValues> extra)`
`93`	`93`	`{`
`94`	`94`	`UnsafeNclNativeMethods.HttpApi.GetUnknownHeaders(extra, _requestMemoryBlob.RequestBuffer,`
`95`		`- _requestMemoryBlob.OriginalBlobAddress);`
	`95`	`+ _requestMemoryBlob.Offset, _requestMemoryBlob.OriginalBlobAddress);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`void IDictionary<string, StringValues>.Add(string key, StringValues value)`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,9 @@ public override unsafe int Read([In, Out] byte[] buffer, int offset, int size)`
`147`	`147`
`148`	`148`	`if (_dataChunkIndex != -1)`
`149`	`149`	`{`
`150`		`- dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
	`150`	`+ dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer,`
	`151`	`+ _requestContext.Request.RequestOffset, _requestContext.Request.OriginalBlobAddress,`
	`152`	`+ ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
`151`	`153`	`}`
`152`	`154`
`153`	`155`	`if (_dataChunkIndex == -1 && dataRead < size)`
`@@ -223,7 +225,9 @@ public override unsafe IAsyncResult BeginRead(byte[] buffer, int offset, int siz`
`223`	`225`	`uint dataRead = 0;`
`224`	`226`	`if (_dataChunkIndex != -1)`
`225`	`227`	`{`
`226`		`- dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
	`228`	`+ dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.RequestOffset,`
	`229`	`+ _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
	`230`	`+`
`227`	`231`	`if (_dataChunkIndex != -1 && dataRead == size)`
`228`	`232`	`{`
`229`	`233`	`asyncResult = new RequestStreamAsyncResult(this, state, callback, buffer, offset, 0);`
`@@ -339,15 +343,16 @@ public override unsafe Task<int> ReadAsync(byte[] buffer, int offset, int size,`
`339`	`343`	`uint dataRead = 0;`
`340`	`344`	`if (_dataChunkIndex != -1)`
`341`	`345`	`{`
`342`		`- dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
	`346`	`+ dataRead = UnsafeNclNativeMethods.HttpApi.GetChunks(_requestContext.Request.RequestBuffer, _requestContext.Request.RequestOffset,`
	`347`	`+ _requestContext.Request.OriginalBlobAddress, ref _dataChunkIndex, ref _dataChunkOffset, buffer, offset, size);`
`343`	`348`	`if (_dataChunkIndex != -1 && dataRead == size)`
`344`	`349`	`{`
`345`	`350`	`UpdateAfterRead(UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS, dataRead);`
`346`	`351`	`// TODO: Verbose log #dataRead`
`347`	`352`	`return Task.FromResult<int>((int)dataRead);`
`348`	`353`	`}`
`349`	`354`	`}`
`350`		`-`
	`355`	`+`
`351`	`356`	`if (_dataChunkIndex == -1 && dataRead < size)`
`352`	`357`	`{`
`353`	`358`	`uint statusCode = 0;`
Original file line number	Diff line number	Diff line change
`@@ -890,7 +890,7 @@ private unsafe ChannelBinding GetChannelBindingFromTls(ulong connectionId)`
`890`	`890`	`blob = new byte[size];`
`891`	`891`	`fixed (byte* blobPtr = blob)`
`892`	`892`	`{`
`893`		`- // Http.sys team: ServiceName will always be null if`
	`893`	`+ // Http.sys team: ServiceName will always be null if`
`894`	`894`	`// HTTP_RECEIVE_SECURE_CHANNEL_TOKEN flag is set.`
`895`	`895`	`statusCode = UnsafeNclNativeMethods.HttpApi.HttpReceiveClientCertificate(`
`896`	`896`	`RequestQueueHandle,`