public bool ReadStatusLine(HttpResponseMessage response)
{
if (!_span.StartsWithHttpPrefix())
{
return(false);
}
int index = HttpPrefix.Length;
int majorVersion = _span.ReadInt(ref index);
CheckResponseMsgFormat(majorVersion != 0);
CheckResponseMsgFormat(index < _span.Length);
int minorVersion;
if (_span[index] == '.')
{
index++;
CheckResponseMsgFormat(index < _span.Length && _span[index] >= '0' && _span[index] <= '9');
minorVersion = _span.ReadInt(ref index);
}
else
{
minorVersion = 0;
}
CheckResponseMsgFormat(_span.SkipSpace(ref index));
// Parse status code.
int statusCode = _span.ReadInt(ref index);
CheckResponseMsgFormat(statusCode >= 100 && statusCode < 1000);
bool foundSpace = _span.SkipSpace(ref index);
CheckResponseMsgFormat(index <= _span.Length);
CheckResponseMsgFormat(foundSpace || index == _span.Length);
// Set the response HttpVersion.
response.Version =
(majorVersion == 1 && minorVersion == 1) ? HttpVersionInternal.Version11 :
(majorVersion == 1 && minorVersion == 0) ? HttpVersionInternal.Version10 :
(majorVersion == 2 && minorVersion == 0) ? HttpVersionInternal.Version20 :
HttpVersionInternal.Unknown;
response.StatusCode = (HttpStatusCode)statusCode;
// Try to use a known reason phrase instead of allocating a new string.
HeaderBufferSpan reasonPhraseSpan = _span.Substring(index);
string knownReasonPhrase = HttpStatusDescription.Get(response.StatusCode);
response.ReasonPhrase = reasonPhraseSpan.EqualsOrdinal(knownReasonPhrase) ?
knownReasonPhrase :
reasonPhraseSpan.ToString();
return(true);
}
private void SendNegotiationErrorResponse(StreamWriter writer, HttpStatusCode code)
{
Int32 intCode = (Int32)code;
writer.Write("HTTP/1.1 ");
writer.Write(intCode);
writer.Write(" ");
writer.Write(HttpStatusDescription.Get(code));
writer.Write("\r\n\r\n");
}
private static string GetReasonPhrase(HttpStatusCode statusCode, char[] buffer, int bufferLength)
{
CharArrayHelpers.DebugAssertArrayInputs(buffer, 0, bufferLength);
Debug.Assert(bufferLength > 0);
// If it's a known reason phrase, use the known reason phrase instead of allocating a new string.
string knownReasonPhrase = HttpStatusDescription.Get(statusCode);
return((knownReasonPhrase != null && CharArrayHelpers.EqualsOrdinal(knownReasonPhrase, buffer, 0, bufferLength)) ?
knownReasonPhrase :
new string(buffer, 0, bufferLength));
}
public HttpErrorViewModel(Exception exception, string controllerName, string actionName)
: base(exception, controllerName, actionName)
{
var http = exception as HttpException;
if (http != null)
{
this.StatusCode = http.GetHttpCode();
}
else
{
this.StatusCode = 500;
}
this.StatusDescription = HttpStatusDescription.Get(this.StatusCode);
}
private void SendNegotiationErrorResponse(StreamWriter writer, HttpStatusCode code)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
var intCode = (int)code;
writer.Write("HTTP/1.1 ");
writer.Write(intCode);
writer.Write(" ");
writer.Write(HttpStatusDescription.Get(code));
writer.Write("\r\n");
writer.Write("Connection: close");
writer.Write("\r\n\r\n");
}
/// <summary>
/// Validates the specified Parameter Id to see if it is a numeric value.
/// </summary>
/// <param name="routeContext">The <see cref="RouteContext" />.</param>
/// <param name="action">The <see cref="ActionDescriptor" />.</param>
/// <returns><see cref="bool" />.</returns>
/// <exception cref="ProblemException">when the passed ID is not a numeric value.</exception>
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action)
{
var identityParameterValue = routeContext.RouteData.Values[identityParameterName];
if (int.TryParse((string)identityParameterValue, out var _))
{
return(true);
}
var problem = new Problem(HttpStatusCode.BadRequest)
{
Detail = $"Invalid {identityParameterName}.",
Title = HttpStatusDescription.Get(HttpStatusCode.BadRequest),
Extensions = new Dictionary <string, object>
{
[identityParameterName] = identityParameterValue
},
Instance = new Uri(routeContext.HttpContext.Request.Path.Value, UriKind.Relative)
};
throw new ProblemException(problem);
}
internal static async Task <HttpListenerWebSocketContext> AcceptWebSocketAsyncCore(HttpListenerContext context,
string subProtocol,
int receiveBufferSize,
TimeSpan keepAliveInterval,
ArraySegment <byte>?internalBuffer = null)
{
ValidateOptions(subProtocol, receiveBufferSize, MinSendBufferSize, keepAliveInterval);
// get property will create a new response if one doesn't exist.
HttpListenerResponse response = context.Response;
HttpListenerRequest request = context.Request;
ValidateWebSocketHeaders(context);
string secWebSocketVersion = request.Headers[HttpKnownHeaderNames.SecWebSocketVersion];
// Optional for non-browser client
string origin = request.Headers[HttpKnownHeaderNames.Origin];
string[] secWebSocketProtocols = null;
string outgoingSecWebSocketProtocolString;
bool shouldSendSecWebSocketProtocolHeader =
ProcessWebSocketProtocolHeader(
request.Headers[HttpKnownHeaderNames.SecWebSocketProtocol],
subProtocol,
out outgoingSecWebSocketProtocolString);
if (shouldSendSecWebSocketProtocolHeader)
{
secWebSocketProtocols = new string[] { outgoingSecWebSocketProtocolString };
response.Headers.Add(HttpKnownHeaderNames.SecWebSocketProtocol, outgoingSecWebSocketProtocolString);
}
// negotiate the websocket key return value
string secWebSocketKey = request.Headers[HttpKnownHeaderNames.SecWebSocketKey];
string secWebSocketAccept = HttpWebSocket.GetSecWebSocketAcceptString(secWebSocketKey);
response.Headers.Add(HttpKnownHeaderNames.Connection, HttpKnownHeaderNames.Upgrade);
response.Headers.Add(HttpKnownHeaderNames.Upgrade, WebSocketUpgradeToken);
response.Headers.Add(HttpKnownHeaderNames.SecWebSocketAccept, secWebSocketAccept);
response.StatusCode = (int)HttpStatusCode.SwitchingProtocols; // HTTP 101
response.StatusDescription = HttpStatusDescription.Get(HttpStatusCode.SwitchingProtocols);
HttpResponseStream responseStream = response.OutputStream as HttpResponseStream;
// Send websocket handshake headers
await responseStream.WriteWebSocketHandshakeHeadersAsync().ConfigureAwait(false);
WebSocket webSocket = WebSocket.CreateFromStream(context.Connection.ConnectedStream, isServer: true, subProtocol, keepAliveInterval);
HttpListenerWebSocketContext webSocketContext = new HttpListenerWebSocketContext(
request.Url,
request.Headers,
request.Cookies,
context.User,
request.IsAuthenticated,
request.IsLocal,
request.IsSecureConnection,
origin,
secWebSocketProtocols != null ? secWebSocketProtocols : Array.Empty <string>(),
secWebSocketVersion,
secWebSocketKey,
webSocket);
return(webSocketContext);
}
private static string BuildExceptionMessage(HttpResponseMessage response)
{
var requestId = TryGetHeaderValue(response, "x-ms-request-id");
var copyStatus = TryGetHeaderValue(response, "x-ms-copy-status");
var exception = "";
if (!response.IsSuccessStatusCode)
{
if (!string.IsNullOrEmpty(requestId))
{
exception = string.Format(CultureInfo.InvariantCulture, $"Response status code does not indicate success: {response.StatusCode} ({HttpStatusDescription.Get(response.StatusCode)}) [{requestId}].");
}
else
{
exception = string.Format(CultureInfo.InvariantCulture, $"Response status code does not indicate success: {response.StatusCode} ({HttpStatusDescription.Get(response.StatusCode)}).");
}
}
else if (!response.IsCopySuccess())
{
if (!string.IsNullOrEmpty(requestId))
{
exception = string.Format(CultureInfo.InvariantCulture, $"Response status code does indicate success but background copy operation failed: {response.StatusCode} ({HttpStatusDescription.Get(response.StatusCode)} | Copy {copyStatus}) [{requestId}].");
}
else
{
exception = string.Format(CultureInfo.InvariantCulture, $"Response status code does indicate success but background copy operation failed: {response.StatusCode} ({HttpStatusDescription.Get(response.StatusCode)} | Copy {copyStatus}).");
}
}
return(exception);
}
internal HttpResponse(HttpStatusCode code)
: this((int)code, HttpStatusDescription.Get(code), HttpVersion.Version11, new NameValueCollection())
{
}
