private void SendMsg()
{
IHttpMessage msg = _messageList[0];
_messageList.Remove(msg);
msg.RequestHandler();
}
static int GetWebSocketContentLength(IHttpMessage message)
{
// WebSocket messages have constant content-lengths.
HttpHeaders h = message.Headers;
if (message is IHttpRequest req)
{
if (HttpMethod.Get.Equals(req.Method) &&
h.Contains(HttpHeaderNames.SecWebsocketKey1) &&
h.Contains(HttpHeaderNames.SecWebsocketKey2))
{
return(8);
}
}
else if (message is IHttpResponse res)
{
if (res.Status.Code == 101 &&
h.Contains(HttpHeaderNames.SecWebsocketOrigin) &&
h.Contains(HttpHeaderNames.SecWebsocketLocation))
{
return(16);
}
}
// Not a web socket message
return(-1);
}
static int GetWebSocketContentLength(IHttpMessage message)
{
// WebSocket messages have constant content-lengths.
HttpHeaders h = message.Headers;
switch (message)
{
case IHttpRequest req:
if (HttpMethod.Get.Equals(req.Method) &&
h.Contains(HttpHeaderNames.SecWebsocketKey1) &&
h.Contains(HttpHeaderNames.SecWebsocketKey2))
{
return(8);
}
break;
case IHttpResponse res:
if (res.Status.Code == StatusCodes.Status101SwitchingProtocols &&
h.Contains(HttpHeaderNames.SecWebsocketOrigin) &&
h.Contains(HttpHeaderNames.SecWebsocketLocation))
{
return(16);
}
break;
}
// Not a web socket message
return(-1);
}
protected virtual bool IsContentAlwaysEmpty(IHttpMessage msg)
{
if (msg is IHttpResponse res)
{
int code = res.Status.Code;
// Correctly handle return codes of 1xx.
//
// See:
// - http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html Section 4.4
// - https://github.com/netty/netty/issues/222
if (code >= 100 && code < 200)
{
// One exception: Hixie 76 websocket handshake response
return(!(code == 101 && !res.Headers.Contains(HttpHeaderNames.SecWebsocketAccept) &&
res.Headers.Contains(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket, true)));
}
switch (code)
{
case 204:
case 304:
return(true);
}
}
return(false);
}
/// <summary>
/// Are about to send a new message
/// </summary>
/// <param name="message">Message to send</param>
/// <remarks>
/// Can be used to prepare the next message. for instance serialize it etc.
/// </remarks>
/// <exception cref="NotSupportedException">Message is of a type that the encoder cannot handle.</exception>
public void Prepare(object message)
{
if (message is IWebSocketMessage)
{
_message = (IWebSocketMessage)message;
_message.Payload.Position = 0;
_totalAmountToSend = (int)_message.Payload.Length;
}
else
{
try
{
_httpMessageEncoder.Prepare(message);
var httpMessage = message as IHttpMessage;
if (WebSocketUtils.IsWebSocketUpgrade(httpMessage))
{
_handshake = httpMessage;
}
}
catch (Exception e)
{
throw new InvalidOperationException("This encoder only supports messages deriving from 'HttpMessage' or 'WebSocketMessage'", e);
}
}
}
internal HttpResponse(string line, IHttpMessage message)
{
validation_code = Validate(line, out var version, out var status);
Version = version;
StatusCode = status;
Message = message;
}
public static void SetTransferEncodingChunked(IHttpMessage m, bool chunked)
{
if (chunked)
{
_ = m.Headers.Set(HttpHeaderNames.TransferEncoding, HttpHeaderValues.Chunked);
_ = m.Headers.Remove(HttpHeaderNames.ContentLength);
}
else
{
IList <ICharSequence> encodings = m.Headers.GetAll(HttpHeaderNames.TransferEncoding);
if (0u >= (uint)encodings.Count)
{
return;
}
var values = new List <ICharSequence>(encodings);
foreach (ICharSequence value in encodings)
{
if (HttpHeaderValues.Chunked.ContentEqualsIgnoreCase(value))
{
_ = values.Remove(value);
}
}
if (0u >= (uint)values.Count)
{
_ = m.Headers.Remove(HttpHeaderNames.TransferEncoding);
}
else
{
_ = m.Headers.Set(HttpHeaderNames.TransferEncoding, values);
}
}
}
/// <summary>
/// Throws a <see cref="ProtocolException"/> if some <paramref name="condition"/> evaluates to false.
/// </summary>
/// <param name="condition">True to do nothing; false to throw the exception.</param>
/// <param name="faultedMessage">The message being processed that would be responsible for the exception if thrown.</param>
/// <param name="errorMessage">The error message for the exception.</param>
/// <param name="args">The string formatting arguments, if any.</param>
/// <exception cref="ProtocolException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
internal static void VerifyProtocol(bool condition, IHttpMessage faultedMessage, string errorMessage, params object[] args)
{
if (!condition)
{
throw new ProtocolException(string.Format(CultureInfo.CurrentCulture, errorMessage, args), faultedMessage);
}
}
public static void Header(this IHttpMessage message, string header, Action <string> onPresent)
{
if (message.Headers.TryGetValue(header, out var headerValue))
{
onPresent(headerValue);
}
}
private void OnReceiveOver(IHttpMessage msg)
{
lock (m_receiveList)
{
m_receiveList.Add(msg);
}
}
public HttpResponse(HttpVersion version, HttpStatusCode code, IHttpMessage message)
{
Version = version;
StatusCode = code;
Message = message;
validation_code = HttpResponseValidationCode.Valid;
}
/// <summary>
/// Are about to send a new message
/// </summary>
/// <param name="message">Message to send</param>
/// <remarks>
/// Can be used to prepare the next message. for instance serialize it etc.
/// </remarks>
/// <exception cref="NotSupportedException">Message is of a type that the encoder cannot handle.</exception>
public void Prepare(object message)
{
if (message is IWebSocketMessage)
{
_message = (IWebSocketMessage)message;
_message.Payload.Position = 0;
_totalAmountToSend = (int)_message.Payload.Length;
}
else
{
try
{
_httpMessageEncoder.Prepare(message);
var httpMessage = message as IHttpMessage;
if (WebSocketUtils.IsWebSocketUpgrade(httpMessage))
{
_handshake = httpMessage;
}
}
catch (Exception e)
{
throw new InvalidOperationException("This encoder only supports messages deriving from 'HttpMessage' or 'WebSocketMessage'", e);
}
}
}
public HttpRequest(HttpRequestKind kind, string resource, HttpVersion version, IHttpMessage message)
{
Kind = kind;
Resource = new Resource(resource);
Version = version;
Message = message;
validation_code = HttpRequestValidationCode.Valid;
}
private void AddHeaderToRequest(IHttpMessage request, string headerLine)
{
var headerParts = headerLine.Split(new[] { ':' }, 2);
var headerName = headerParts[0].Trim();
var headerValue = headerParts.Length == 2 ? headerParts[1].Trim() : string.Empty;
request.AddHeader(headerName, headerValue);
}
internal HttpBody(IHttpMessage message)
{
this.message = message;
ContentType = message.ContentType;
EncodingText = message.ContentTransferEncoding;
CharSet = EncodingText.WebName;
}
private HttpRequest(string line, IHttpMessage message)
{
validation_code = Validate(line, out var kind, out var resource, out var version);
Kind = kind;
Resource = resource;
Version = version;
Message = message;
}
static void AppendCommon(StringBuilder buf, IHttpMessage msg)
{
_ = buf.Append($"{StringUtil.SimpleClassName(msg)}");
_ = buf.Append("(decodeResult: ");
_ = buf.Append(msg.Result);
_ = buf.Append(", version: ");
_ = buf.Append(msg.ProtocolVersion);
_ = buf.Append($"){StringUtil.Newline}");
}
/// <summary>
/// Reset decoder state so that we can decode a new message
/// </summary>
public void Clear()
{
_httpMessageDecoder.Clear();
_handshake = null;
_frame = null;
_frames = new List <WebSocketFrame>();
_frameContentBytesLeft = 0;
_isWebSocket = false;
}
private void LoadNext()
{
if (_messageList.Count > 0)
{
IHttpMessage msg = _messageList[0];
_messageList.RemoveAt(0);
NetWorkManager.Instance.Send(msg);
}
}
protected override void ChannelRead0(IChannelHandlerContext ctx, IHttpMessage msg)
{
// If this handler is hit then no upgrade has been attempted and the client is just talking HTTP.
s_logger.LogInformation("Directly talking: " + msg.ProtocolVersion + " (no upgrade was attempted)");
IChannelPipeline pipeline = ctx.Pipeline;
pipeline.AddAfter(ctx.Name, null, new Http2Helloworld.Server.HelloWorldHttp1Handler("Direct. No Upgrade Attempted."));
pipeline.Replace(this, null, new HttpObjectAggregator(this.maxHttpContentLength));
ctx.FireChannelRead(ReferenceCountUtil.Retain(msg));
}
internal static bool IsUnsupportedExpectation(IHttpMessage message)
{
if (!IsExpectHeaderValid(message))
{
return(false);
}
return(message.Headers.TryGet(HttpHeaderNames.Expect, out ICharSequence expectValue) &&
!HttpHeaderValues.Continue.ContentEqualsIgnoreCase(expectValue));
}
public static void AppendList(this IHttpMessage message, string header, string value)
{
if (message.Headers.ContainsKey(header) && message.Headers[header].Trim().Length > 0)
{
message.Headers[header] += ", " + value;
}
else
{
message.Headers[header] = value;
}
}
public static void Set100ContinueExpected(IHttpMessage message, bool expected)
{
if (expected)
{
_ = message.Headers.Set(HttpHeaderNames.Expect, HttpHeaderValues.Continue);
}
else
{
_ = message.Headers.Remove(HttpHeaderNames.Expect);
}
}
public static bool Is100ContinueExpected(IHttpMessage message)
{
if (!IsExpectHeaderValid(message))
{
return(false);
}
ICharSequence expectValue = message.Headers.Get(HttpHeaderNames.Expect, null);
// unquoted tokens in the expect header are case-insensitive, thus 100-continue is case insensitive
return(HttpHeaderValues.Continue.ContentEqualsIgnoreCase(expectValue));
}
public void Send(IHttpMessage msg)
{
if (Serverurl != null)
{
_messageList.Add(msg);
SendMsg();
}
else
{
Debug.LogError("NetWorkManager.SERVER 为空！");
}
}
public void upgrade()
{
IHttpMessage actual = null;
var decoder = new WebSocketDecoder();
decoder.MessageReceived = o => actual = (IHttpMessage)o;
sendWebSocketUpgradeRequest(decoder);
actual.Headers["host"].Should().Be("localhost");
actual.Headers["connection"].Should().Be("upgrade");
actual.Headers["upgrade"].Should().Be("websocket");
}
/// <summary>
/// Intercept http messages and look for websocket upgrade requests
/// </summary>
/// <param name="message">message from http decoder</param>
private void OnHttpMessage(object message)
{
var httpMessage = message as IHttpMessage;
// TODO: is there a better way to detect WebSocket upgrade?
if (WebSocketUtils.IsWebSocketUpgrade(httpMessage))
{
_handshake = httpMessage;
_isWebSocket = true;
}
_messageReceived(message);
}
public override void Deserialization(Node localNode, Route route, IHttpMessage httpMessage)
{
Source = httpMessage.Head.GetField(HttpConst.MessageSource).Value;
Destiny = httpMessage.Head.GetField(HttpConst.MessageDestiny).Value;
Path = httpMessage.Head.GetField(HttpConst.MessagePath).Value;
Hops = int.Parse(httpMessage.Head.GetField(HttpConst.MessageHops).Value);
var formatter = new BinaryFormatter();
httpMessage.Body.ContentStream.Position = 0;
Payload = formatter.Deserialize(httpMessage.Body.ContentStream) as OverlayMessage;
}
IHttpContent InvalidChunk(IByteBuffer buf, Exception cause)
{
this.currentState = State.BadMessage;
// Advance the readerIndex so that ByteToMessageDecoder does not complain
// when we produced an invalid message without consuming anything.
buf.SkipBytes(buf.ReadableBytes);
IHttpContent chunk = new DefaultLastHttpContent(Unpooled.Empty);
chunk.Result = DecoderResult.Failure(cause);
this.message = null;
this.trailer = null;
return(chunk);
}
public static bool IsKeepAlive(IHttpMessage message)
{
if (message.Headers.TryGet(HttpHeaderNames.Connection, out ICharSequence connection) &&
HttpHeaderValues.Close.ContentEqualsIgnoreCase(connection))
{
return(false);
}
if (message.ProtocolVersion.IsKeepAliveDefault)
{
return(!HttpHeaderValues.Close.ContentEqualsIgnoreCase(connection));
}
else
{
return(HttpHeaderValues.KeepAlive.ContentEqualsIgnoreCase(connection));
}
}
private bool IsContentTypeSpecifiedForBody(IHttpMessage message)
{
//No content-type required if there is no body
if (message.Body == null)
{
return(true);
}
IDictionary <string, object> headers = null;
if (message.Headers != null)
{
headers = new Dictionary <string, object>(message.Headers, StringComparer.OrdinalIgnoreCase);
}
return(headers != null && headers.ContainsKey("Content-Type"));
}
static void AssertRequest(TestRequest[] expected, IHttpMessage[] actual)
{
for (int i = 0; i < expected.Length; i++)
{
Assert.IsTrue(i <= actual.Length - 1, "Expected more requests than received");
var expectedRequest = expected[i];
var actualRequest = actual[i];
//Console.WriteLine("Asserting request " + expectedRequest.Name);
Assert.AreEqual(expectedRequest.Method, actualRequest.Method, "Unexpected method.");
Assert.AreEqual(expectedRequest.RequestUri, actualRequest.RequestUri, "Unexpected request URI.");
Assert.AreEqual(expectedRequest.VersionMajor, actualRequest.HttpVersion.Major, "Unexpected major version.");
Assert.AreEqual(expectedRequest.VersionMinor, actualRequest.HttpVersion.Minor, "Unexpected minor version.");
Assert.AreEqual(expectedRequest.RequestPath, actualRequest.RequestPath, "Unexpected request path.");
Assert.AreEqual(expectedRequest.QueryString, actualRequest.QueryString, "Unexpected query string.");
Assert.AreEqual(expectedRequest.Fragment, actualRequest.Fragment, "Unexpected fragment.");
//Assert.AreEqual(expected.RequestPath, test.RequestPath, "Unexpected path.");
Assert.AreEqual(expectedRequest.ShouldKeepAlive, actualRequest.ShouldKeepAlive, "Wrong value for ShouldKeepAlive");
foreach (var pair in expectedRequest.Headers)
{
Assert.IsTrue(actualRequest.Headers.Any(h => string.Equals(h.Key, pair.Key, StringComparison.OrdinalIgnoreCase)), "Actual headers did not contain key '" + pair.Key + "'");
Assert.AreEqual(pair.Value, actualRequest.Headers.Where(h => string.Equals(h.Key, pair.Key, StringComparison.OrdinalIgnoreCase)).Select(h => h.Value).First(), "Actual headers had wrong value for key '" + pair.Key + "'");
}
foreach (var pair in actualRequest.Headers)
{
Assert.IsTrue(expectedRequest.Headers.ContainsKey(pair.Key), "Unexpected header named '" + pair.Key + "'");
}
if (expectedRequest.Body != null)
{
var expectedBody = Encoding.UTF8.GetString(expectedRequest.Body);
Assert.IsNotNull(actualRequest.Body, "Expected non-null request body");
StreamReader sr = new StreamReader(actualRequest.Body, Encoding.UTF8);
var actualBody = sr.ReadToEnd();
Assert.AreEqual(expectedBody, actualBody, "Body differs");
}
else
Assert.AreEqual(0, actualRequest.Body.Length);
}
}
/// <summary>
/// Check if http message is a valid WebSocket upgrade request
/// </summary>
/// <param name="httpMessage">message to check</param>
/// <returns>true if message is a valid WebSocket upgrade request</returns>
public static bool IsWebSocketUpgrade(IHttpMessage httpMessage)
{
return httpMessage != null &&
(httpMessage.Headers["Connection"] ?? string.Empty).IndexOf("upgrade", StringComparison.OrdinalIgnoreCase) != -1 &&
(httpMessage.Headers["Upgrade"] ?? string.Empty).IndexOf("websocket", StringComparison.OrdinalIgnoreCase) != -1;
}
/// <summary>
/// Reset decoder state so that we can decode a new message
/// </summary>
public void Clear()
{
_httpMessageDecoder.Clear();
_handshake = null;
_frame = null;
_frames = new List<WebSocketFrame>();
_frameContentBytesLeft = 0;
_isWebSocket = false;
}
/// <summary>
/// Intercept http messages and look for websocket upgrade requests
/// </summary>
/// <param name="message">message from http decoder</param>
private void OnHttpMessage(object message)
{
var httpMessage = message as IHttpMessage;
// TODO: is there a better way to detect WebSocket upgrade?
if (WebSocketUtils.IsWebSocketUpgrade(httpMessage))
{
_handshake = httpMessage;
_isWebSocket = true;
}
_messageReceived(message);
}
private void ReadResponse(IHttpMessage response)
{
response.Entity.Stream.Position = 0;
ResponseText = new StreamReader(response.Entity.Stream).ReadToEnd();
}
/// <summary>
/// Creates a test configuration for an operation in the batch.
/// </summary>
/// <param name="operation">The operation to get the configuration for.</param>
/// <returns>Test configuration based on the batch test configuration with the format modified to apply to the operation in question.</returns>
private ReaderTestConfiguration GetOperationTestConfiguration(IHttpMessage operation)
{
string contentType = operation.GetHeaderValueIfExists(Microsoft.OData.Core.ODataConstants.ContentTypeHeader);
ODataFormat format = this.batchTestConfiguration.Format;
if (IsAtomMimeType(contentType))
{
format = ODataFormat.Atom;
}
else if (IsJsonMimeType(contentType))
{
format = ODataFormat.Json;
}
return new ReaderTestConfiguration(
format,
this.batchTestConfiguration.MessageReaderSettings,
this.batchTestConfiguration.IsRequest,
this.batchTestConfiguration.Synchronous,
this.batchTestConfiguration.Version);
}
/// <summary>
/// Initializes a new instance of the <see cref="RequestValueProvider" /> class.
/// </summary>
/// <param name="request">The request.</param>
public RequestValueProvider(IHttpMessage request)
{
_request = request;
}
