public WebSocketFrameParseResult(WebSocketFrame webSocketFrame, byte[] overhead)
{
if (webSocketFrame == null) throw new ArgumentNullException(nameof(webSocketFrame));
if (overhead == null) throw new ArgumentNullException(nameof(overhead));
WebSocketFrame = webSocketFrame;
Overhead = overhead;
}
/// <summary>
/// It will send the given frame to the server.
/// </summary>
public void Send(WebSocketFrame frame)
{
if (frame == null)
{
throw new ArgumentNullException("frame is null!");
}
if (closed)
{
return;
}
byte[] rawData = frame.Get();
lock (SendLock)
{
Stream.Write(rawData, 0, rawData.Length);
Stream.Flush();
if (frame.Type == WebSocketFrameTypes.ConnectionClose)
{
closeSent = true;
}
}
}
private void WriteWebSocketFrame(DataWriter writer, WebSocketFrame frame)
{
if (frame.PayloadLength > MaxPacketLength)
{
throw new Exception("packet length exceeds maxPacketLength.");
}
var stream = (SendStream)writer.BaseStream;
writer.Write((byte)(((frame.IsFrameEndOf ? 1 : 0) << 7) | (int)frame.Opcode));
if (frame.PayloadLength < 126)
{
writer.Write((byte)(((stream.IsMask ? 1 : 0) << 7) | frame.PayloadLength));
}
else if (frame.PayloadLength < ushort.MaxValue)
{
writer.Write((byte)(((stream.IsMask ? 1 : 0) << 7) | 126));
writer.Write(((ushort)frame.PayloadLength).SwapUInt16());
}
else
{
writer.Write((byte)(((stream.IsMask ? 1 : 0) << 7) | 127));
writer.Write(((ulong)frame.PayloadLength).SwapUInt64());
}
if (!stream.IsMask)
{
writer.Write(frame.PayloadData);
}
else
{
writer.Write(stream.MaskingKey);
writer.Write(frame.PayloadData);
stream.GobackMasking(frame.PayloadLength);
}
}
/// <summary>
/// It will send the given frame to the server.
/// </summary>
public void Send(WebSocketFrame frame)
{
if (frame == null)
{
throw new ArgumentNullException("frame is null!");
}
if (closed || closeSent)
{
return;
}
lock (SendLock)
{
this.unsentFrames.Add(frame);
if (!sendThreadCreated)
{
#if NETFX_CORE
#pragma warning disable 4014
Windows.System.Threading.ThreadPool.RunAsync(SendThreadFunc);
#pragma warning restore 4014
#else
ThreadPool.QueueUserWorkItem(SendThreadFunc);
#endif
sendThreadCreated = true;
}
}
Interlocked.Add(ref this._bufferedAmount, frame.Data != null ? frame.Data.Length : 0);
//if (HTTPManager.Logger.Level <= Logger.Loglevels.All)
// HTTPManager.Logger.Information("WebSocketResponse", "Signaling SendThread!");
newFrameSignal.Set();
}
public Dictionary <string, Dictionary <string, bool> > Broadping(string message)
{
Dictionary <string, Dictionary <string, bool> > strs;
if ((message == null ? false : message.Length != 0))
{
byte[] numArray = null;
string str = ((ServerState)this._state).CheckIfAvailable(false, true, false) ?? WebSocket.CheckPingParameter(message, out numArray);
if (str == null)
{
strs = this.broadping(WebSocketFrame.CreatePingFrame(numArray, false).ToArray(), this._waitTime);
}
else
{
this._logger.Error(str);
strs = null;
}
}
else
{
strs = this.Broadping();
}
return(strs);
}
/// <summary>
/// Receives the asynchronous.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="result">The result.</param>
/// <param name="buffer">The buffer.</param>
/// <returns></returns>
public override async Task ReceiveAsync(WebSocket socket, WebSocketReceiveResult result, byte[] buffer)
{
var beaconId = WebSocketManager.GetId(socket);
var frame = WebSocketFrame.Decode(Encoding.UTF8.GetString(buffer));
switch (frame.Type)
{
case FrameType.Connect:
case FrameType.ToBeacon:
Console.WriteLine("Server doesn't need to handle Connect/ToBeacon frames");
break;
case FrameType.Stager:
// Get stager from server channel
var stager = GetStager(beaconId, frame.Buffer[0] == 0x64);
var stageFrame = new WebSocketFrame(FrameType.Stager, beaconId.InternalId, stager);
// Send stager to beacon channel
await SendMessageAsync(beaconId, stageFrame.Encode());
break;
case FrameType.ToServer:
// Send frame to server channel
SendFrame(beaconId, frame.Buffer);
// Read frame from server channel
var respFrame = new WebSocketFrame(FrameType.ToBeacon, beaconId.InternalId, ReadFrame(beaconId));
// Send frame to beacon channel
await SendMessageAsync(beaconId, respFrame.Encode());
break;
default:
Console.WriteLine("Unknown frame type...");
break;
}
}
private void streamData(object sender, ElapsedEventArgs e)
{
streamTimer.Interval = streamRate;
DataSources dataSources = new DataSources();
if (toRun.Count + subscriptions.Count > 0)
{
try
{
List <string> entries = new List <string>();
APIEntry entry = null;
lock (subscriptionLock)
{
dataSources.vessel = kspAPI.getVessel();
//Only parse the paused argument if the active vessel is null
if (dataSources.vessel != null)
{
toRun.UnionWith(subscriptions);
foreach (string s in toRun)
{
DataSources dataSourcesClone = dataSources.Clone();
string trimedQuotes = s.Trim();
string refArg = trimedQuotes;
kspAPI.parseParams(ref refArg, ref dataSourcesClone);
kspAPI.process(refArg, out entry);
if (entry != null)
{
dataSourcesClone.setVarName(trimedQuotes);
entries.Add(entry.formatter.format(entry.function(dataSourcesClone), dataSourcesClone.getVarName()));
}
}
toRun.Clear();
if (entry != null)
{
WebSocketFrame frame = new WebSocketFrame(ASCIIEncoding.UTF8.GetBytes(entry.formatter.pack(entries)));
byte[] bFrame = frame.AsBytes();
dataRates.addDownLinkPoint(System.DateTime.Now, bFrame.Length * UpLinkDownLinkRate.BITS_PER_BYTE);
clientConnection.Send(bFrame);
}
}
else
{
sendNullMessage();
}
}
}
catch (NullReferenceException)
{
PluginLogger.debug("Swallowing null reference exception, potentially due to async game state change.");
sendNullMessage();
}
catch (Exception ex)
{
PluginLogger.debug("Closing socket due to potential client disconnect:" + ex.GetType().ToString());
close();
}
}
else
{
sendNullMessage();
}
}
// As server, used to broadcast
internal void Send (Opcode opcode, byte[] data, Dictionary<CompressionMethod, byte[]> cache)
{
lock (_forSend) {
lock (_forConn) {
if (_readyState != WebSocketState.Open) {
_logger.Error ("The sending has been interrupted.");
return;
}
try {
byte[] cached;
if (!cache.TryGetValue (_compression, out cached)) {
cached = new WebSocketFrame (
Fin.Final,
opcode,
data.Compress (_compression),
_compression != CompressionMethod.None,
false)
.ToArray ();
cache.Add (_compression, cached);
}
sendBytes (cached);
}
catch (Exception ex) {
_logger.Fatal (ex.ToString ());
}
}
}
}
private bool processPingFrame (WebSocketFrame frame)
{
if (send (new WebSocketFrame (Opcode.Pong, frame.PayloadData, _client).ToArray ()))
_logger.Trace ("Returned a Pong.");
if (_emitOnPing)
enqueueToMessageEventQueue (new MessageEventArgs (frame));
return true;
}
public void OpCodeText(object sender, FrameEventArgs e)
{
WebSocketFrame frame = new WebSocketFrame(ASCIIEncoding.UTF8.GetBytes("Echo: " + e.frame.PayloadAsUTF8()));
e.clientConnection.Send(frame.AsBytes());
}
internal MessageEventArgs(WebSocketFrame frame)
{
_opcode = frame.Opcode;
_rawData = frame.PayloadData.ApplicationData;
}
internal WebSocketResponse(WebSocketFrame frame)
: base(frame.Opcode, frame.Payload)
{
}
protected override int NewRsv(WebSocketFrame msg) => msg.Rsv ^ WebSocketRsv.Rsv1;
internal MessageEventArgs(WebSocketFrame frame)
{
_opcode = frame.Opcode;
_rawData = frame.PayloadData.ApplicationData;
_data = convertToString (_opcode, _rawData);
}
private void streamData(object sender, ElapsedEventArgs e)
{
streamTimer.Interval = streamRate;
DataSources dataSources = new DataSources();
if (toRun.Count + subscriptions.Count > 0)
{
try
{
List<string> entries = new List<string>();
APIEntry entry = null;
lock (subscriptionLock)
{
dataSources.vessel = kspAPI.getVessel();
//Only parse the paused argument if the active vessel is null
if (dataSources.vessel != null)
{
toRun.UnionWith(subscriptions);
foreach (string s in toRun)
{
DataSources dataSourcesClone = dataSources.Clone();
string trimedQuotes = s.Trim();
string refArg = trimedQuotes;
kspAPI.parseParams(ref refArg, ref dataSourcesClone);
kspAPI.process(refArg, out entry);
if (entry != null)
{
entry.formatter.setVarName(trimedQuotes);
entries.Add(entry.formatter.format(entry.function(dataSourcesClone)));
}
}
toRun.Clear();
if (entry != null)
{
WebSocketFrame frame = new WebSocketFrame(ASCIIEncoding.UTF8.GetBytes(entry.formatter.pack(entries)));
byte[] bFrame = frame.AsBytes();
dataRates.addDownLinkPoint(System.DateTime.Now, bFrame.Length * UpLinkDownLinkRate.BITS_PER_BYTE);
clientConnection.Send(bFrame);
}
}
else
{
sendNullMessage();
}
}
}
catch(NullReferenceException)
{
PluginLogger.debug("Swallowing null reference exception, potentially due to async game state change.");
sendNullMessage();
}
catch (Exception ex)
{
PluginLogger.debug("Closing socket due to potential client disconnect:" + ex.GetType().ToString());
close();
}
}
else
{
sendNullMessage();
}
}
public bool MustSkip(WebSocketFrame frame)
{
return((frame is TextWebSocketFrame || frame is BinaryWebSocketFrame) && frame.Content.ReadableBytes < 100);
}
private void SendThreadFunc(object param)
{
List <WebSocketFrame> localFrames = new List <WebSocketFrame>();
try
{
while (!closed && !closeSent)
{
if (HTTPManager.Logger.Level <= Logger.Loglevels.Information)
{
HTTPManager.Logger.Information("WebSocketResponse", "SendThread - Waiting...");
}
newFrameSignal.WaitOne();
try
{
lock (SendLock)
{
// add frames reversed in order
for (int i = this.unsentFrames.Count - 1; i >= 0; --i)
{
localFrames.Add(this.unsentFrames[i]);
}
this.unsentFrames.Clear();
}
if (HTTPManager.Logger.Level <= Logger.Loglevels.Information)
{
HTTPManager.Logger.Information("WebSocketResponse", "SendThread - Wait is over, " + localFrames.Count.ToString() + " new frames!");
}
while (localFrames.Count > 0)
{
WebSocketFrame frame = localFrames[localFrames.Count - 1];
localFrames.RemoveAt(localFrames.Count - 1);
if (!closeSent)
{
byte[] rawData = frame.Get();
Stream.Write(rawData, 0, rawData.Length);
Stream.Flush();
if (frame.Type == WebSocketFrameTypes.ConnectionClose)
{
closeSent = true;
}
}
Interlocked.Add(ref this._bufferedAmount, -frame.Data.Length);
}
}
catch (Exception ex)
{
if (HTTPUpdateDelegator.IsCreated)
{
this.baseRequest.Exception = ex;
this.baseRequest.State = HTTPRequestStates.Error;
}
else
{
this.baseRequest.State = HTTPRequestStates.Aborted;
}
closed = true;
}
}
}
finally
{
sendThreadCreated = false;
HTTPManager.Logger.Information("WebSocketResponse", "SendThread - Closed!");
}
}
internal WebSocketRequest(IHttpRequest handshake, WebSocketFrame frame)
: base(frame.Opcode, frame.Payload)
{
_handshake = handshake;
_frame = frame;
}
private string checkIfValidReceivedFrame(WebSocketFrame frame)
{
var masked = frame.IsMasked;
return _client && masked
? "A frame from the server is masked."
: !_client && !masked
? "A frame from a client isn't masked."
: frame.IsCompressed && _compression == CompressionMethod.None
? "A compressed frame is without the available decompression method."
: null;
}
protected override bool AppendFrameTail(WebSocketFrame msg) => true;
private bool checkReceivedFrame (WebSocketFrame frame, out string message)
{
message = null;
var masked = frame.IsMasked;
if (_client && masked) {
message = "A frame from the server is masked.";
return false;
}
if (!_client && !masked) {
message = "A frame from a client isn't masked.";
return false;
}
if (_inContinuation && frame.IsData) {
message = "A data frame has been received while receiving continuation frames.";
return false;
}
if (frame.IsCompressed && _compression == CompressionMethod.None) {
message = "A compressed frame has been received without any agreement for it.";
return false;
}
if (frame.Rsv2 == Rsv.On) {
message = "The RSV2 of a frame is non-zero without any negotiation for it.";
return false;
}
if (frame.Rsv3 == Rsv.On) {
message = "The RSV3 of a frame is non-zero without any negotiation for it.";
return false;
}
return true;
}
public bool MustSkip(WebSocketFrame frame)
{
return(frame.Content.ReadableBytes < 100);
}
protected abstract int NewRsv(WebSocketFrame msg);
public abstract Task ProcessFrame(WebSocketFrame f);
private bool processDataFrame (WebSocketFrame frame)
{
enqueueToMessageEventQueue (
frame.IsCompressed
? new MessageEventArgs (
frame.Opcode, frame.PayloadData.ApplicationData.Decompress (_compression))
: new MessageEventArgs (frame));
return true;
}
public abstract Task ProcessReceivedFrame(WebSocketFrame f);
private bool processReceivedFrame (WebSocketFrame frame)
{
var msg = checkIfValidReceivedFrame (frame);
if (msg != null)
return processUnsupportedFrame (frame, CloseStatusCode.ProtocolError, msg);
frame.Unmask ();
return frame.IsFragmented
? processFragmentedFrame (frame)
: frame.IsData
? processDataFrame (frame)
: frame.IsPing
? processPingFrame (frame)
: frame.IsPong
? processPongFrame (frame)
: frame.IsClose
? processCloseFrame (frame)
: processUnsupportedFrame (frame, CloseStatusCode.UnsupportedData, null);
}
private bool processCloseFrame(WebSocketFrame frame)
{
enqueueToMessageEventQueue(new MessageEventArgs(frame));
return false;
}
private bool processCloseFrame (WebSocketFrame frame)
{
var payload = frame.PayloadData;
close (new CloseEventArgs (payload), !payload.IncludesReservedCloseStatusCode, false);
return false;
}
public void OpCodeText(object sender, FrameEventArgs e)
{
WebSocketFrame frame = new WebSocketFrame(ASCIIEncoding.UTF8.GetBytes("Echo: " + e.frame.PayloadAsUTF8()));
e.clientConnection.Send(frame.AsBytes());
}
protected void sendNullMessage()
{
WebSocketFrame frame = new WebSocketFrame(ASCIIEncoding.UTF8.GetBytes("{}"));
clientConnection.Send(frame.AsBytes());
}
public async Task SendMessageAsync(WebSocketFrame frame)
{
await Channel.WriteAndFlushAsync(frame);
}
protected override void Decode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output)
{
// unused
}
private bool processFragments(WebSocketFrame first)
{
using (var buff = new MemoryStream ()) {
buff.WriteBytes (first.PayloadData.ApplicationData);
if (!concatenateFragmentsInto (buff))
return false;
byte[] data;
if (_compression != CompressionMethod.None) {
data = buff.DecompressToArray (_compression);
}
else {
buff.Close ();
data = buff.ToArray ();
}
enqueueToMessageEventQueue (new MessageEventArgs (first.Opcode, data));
return true;
}
}
public MessageEventArgs(WebSocketUser user, WebSocketFrame message)
{
User = user;
Message = message;
}
private bool processReceivedFrame (WebSocketFrame frame)
{
string msg;
if (!checkReceivedFrame (frame, out msg))
throw new WebSocketException (CloseStatusCode.ProtocolError, msg);
frame.Unmask ();
return frame.IsFragment
? processFragmentFrame (frame)
: frame.IsData
? processDataFrame (frame)
: frame.IsPing
? processPingFrame (frame)
: frame.IsPong
? processPongFrame (frame)
: frame.IsClose
? processCloseFrame (frame)
: processUnsupportedFrame (frame);
}
private bool processFragmentedFrame(WebSocketFrame frame)
{
// Must process first fragment.
return frame.IsContinuation || processFragments (frame);
}
void HandleWebSocketFrame(IChannelHandlerContext ctx, WebSocketFrame frame)
{
// Check for closing frame
if (frame is CloseWebSocketFrame)
{
this.handshaker.CloseAsync(ctx.Channel, (CloseWebSocketFrame)frame.Retain());
return;
}
if (frame is PingWebSocketFrame)
{
ctx.WriteAsync(new PongWebSocketFrame((IByteBuffer)frame.Content.Retain()));
return;
}
if (frame is TextWebSocketFrame)
{
// Echo the frame
String requestmsg = ((TextWebSocketFrame)frame).Text();
IMMessage iMMessage = new IMMessage();
iMMessage = JsonHandler.DeserializeJsonToObject <IMMessage>(requestmsg);
//0为登陆，保存管道
if (iMMessage.msgType == 0)
{
#region 登陆
//app
if (iMMessage.pipetype == "0")
{
try
{
IChannel jieshourenctx = AppUsers[iMMessage.uid];
AppUsers.Add(iMMessage.uid, ctx.Channel);
}
catch
{
AppUsers.Remove(iMMessage.uid);
AppUsers.Add(iMMessage.uid, ctx.Channel);
}
}
//web
if (iMMessage.pipetype == "1")
{
try
{
IChannel jieshourenctx = WebUsers[iMMessage.uid];
WebUsers.Add(iMMessage.uid, ctx.Channel);
}
catch
{
WebUsers.Remove(iMMessage.uid);
WebUsers.Add(iMMessage.uid, ctx.Channel);
}
}
#endregion
List <IMMessage> list = new List <IMMessage>();
#region 取出所有消息并且反序列化
//取出所有消息并且反序列化
var b = redisHelper.ListRange(iMMessage.uid).ToList();
foreach (var item in b)
{
IMMessage sendiMMessage = new IMMessage();
sendiMMessage = JsonHandler.DeserializeJsonToObject <IMMessage>(item);
list.Add(sendiMMessage);
}
//删除此键
if (b.Count() != 0)
{
//删除
redisHelper.KeyDelete(iMMessage.uid);
}
#endregion
//遍历发送
foreach (var senditem in list)
{
if (senditem.msgStatus == "0" && senditem.receiveId == iMMessage.uid)
{
ctx.WriteAsync(new TextWebSocketFrame("来自历史纪录：" + senditem.toString()));
var a = redisHelper.ListRightPush <IMMessage>("send", senditem);
}
}
ctx.Flush();
}
//发信
else
{
try
{
IChannel receiveNameApp = AppUsers[iMMessage.receiveId];
IChannel receiveNameWeb = WebUsers[iMMessage.receiveId];
//没有登陆地
if (receiveNameApp == null && receiveNameWeb == null)
{
//写入缓存
iMMessage.msgStatus = "0";
redisHelper.ListRightPush <IMMessage>(iMMessage.receiveId, iMMessage);
ctx.WriteAsync(new TextWebSocketFrame("发送成功"));
}
else
{
if (receiveNameApp != null)
{
receiveNameApp.WriteAsync(new TextWebSocketFrame("接收到了：" + requestmsg));
receiveNameApp.Flush();
}
if (receiveNameWeb != null)
{
receiveNameWeb.WriteAsync(new TextWebSocketFrame("接收到了：" + requestmsg));
receiveNameWeb.Flush();
}
}
//ctx.WriteAsync(frame.Retain());
ctx.WriteAsync(new TextWebSocketFrame("发送成功"));
var a = redisHelper.ListRightPush <IMMessage>("send", iMMessage);
}
catch
{
}
}
return;
}
if (frame is BinaryWebSocketFrame)
{
// Echo the frame
ctx.WriteAsync(frame.Retain());
}
}
private bool processPingFrame(WebSocketFrame frame)
{
if (send (new WebSocketFrame (Opcode.Pong, frame.PayloadData, _client).ToByteArray ()))
_logger.Trace ("Returned a Pong.");
return true;
}
protected override int NewRsv(WebSocketFrame msg) => (msg.Rsv & WebSocketRsv.Rsv1) > 0 ? msg.Rsv ^ WebSocketRsv.Rsv1 : msg.Rsv;
private bool processUnsupportedFrame (WebSocketFrame frame)
{
_logger.Fatal ("An unsupported frame:" + frame.PrintToString (false));
fatal ("There is no way to handle it.", CloseStatusCode.PolicyViolation);
return false;
}
private bool acceptPingFrame(WebSocketFrame frame)
{
var mask = _client ? Mask.Mask : Mask.Unmask;
if (send (WebSocketFrame.CreatePongFrame (mask, frame.PayloadData)))
_logger.Trace ("Returned a Pong.");
return true;
}
protected override int Rsv(WebSocketFrame msg) =>
msg is TextWebSocketFrame || msg is BinaryWebSocketFrame
? msg.Rsv | WebSocketRsv.Rsv1
: msg.Rsv;
private bool send(WebSocketFrame frame)
{
lock (_forConn) {
if (_readyState != WebSocketState.Open) {
_logger.Warn ("Sending has been interrupted.");
return false;
}
return _stream.Write (frame.ToByteArray ());
}
}
protected abstract bool AppendFrameTail(WebSocketFrame msg);
private const int MAX_FRAME_SIZE = 1024 * 64; //Max size of frame - 512kb. Separate data by frames if more
public WebSocketFrame ReadMessage(NetworkStream stream) //TODO check if frame is too big and separate
{
var a = WebSocketFrame.ReadFrame(stream, true);
return(a);
}
protected internal override void Decode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output)
{
if (this.decoder == null)
{
if (!(msg is TextWebSocketFrame) && !(msg is BinaryWebSocketFrame))
{
throw new CodecException($"unexpected initial frame type: {msg.GetType().Name}");
}
this.decoder = new EmbeddedChannel(ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None));
}
bool readable = msg.Content.IsReadable();
this.decoder.WriteInbound(msg.Content.Retain());
if (this.AppendFrameTail(msg))
{
this.decoder.WriteInbound(Unpooled.WrappedBuffer(FrameTail));
}
CompositeByteBuffer compositeUncompressedContent = ctx.Allocator.CompositeDirectBuffer();
for (;;)
{
var partUncompressedContent = this.decoder.ReadInbound <IByteBuffer>();
if (partUncompressedContent == null)
{
break;
}
if (!partUncompressedContent.IsReadable())
{
partUncompressedContent.Release();
continue;
}
compositeUncompressedContent.AddComponent(true, partUncompressedContent);
}
// Correctly handle empty frames
// See https://github.com/netty/netty/issues/4348
if (readable && compositeUncompressedContent.NumComponents <= 0)
{
compositeUncompressedContent.Release();
throw new CodecException("cannot read uncompressed buffer");
}
if (msg.IsFinalFragment && this.noContext)
{
this.Cleanup();
}
WebSocketFrame outMsg;
if (msg is TextWebSocketFrame)
{
outMsg = new TextWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent);
}
else if (msg is BinaryWebSocketFrame)
{
outMsg = new BinaryWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent);
}
else if (msg is ContinuationWebSocketFrame)
{
outMsg = new ContinuationWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent);
}
else
{
throw new CodecException($"unexpected frame type: {msg.GetType().Name}");
}
output.Add(outMsg);
}
public WebSocketReadCursor(WebSocketFrame frame, int numBytesRead, int numBytesLeftToRead)
{
WebSocketFrame = frame;
NumBytesRead = numBytesRead;
NumBytesLeftToRead = numBytesLeftToRead;
}
/// <inheritdoc /> protected override bool RemoveFrameTail(WebSocketFrame msg) => msg.IsFinalFragment;
private bool processCloseFrame(WebSocketFrame frame)
{
var payload = frame.PayloadData;
close(payload, !payload.ContainsReservedCloseStatusCode, false);
return false;
}
private bool processFragmentedFrame (WebSocketFrame frame)
{
if (!_inContinuation) {
// Must process first fragment.
if (frame.IsContinuation)
return true;
_fopcode = frame.Opcode;
_fragmentsBuffer = new MemoryStream ();
_inContinuation = true;
}
_fragmentsBuffer.WriteBytes (frame.PayloadData.ApplicationData);
if (frame.IsFinal) {
using (_fragmentsBuffer) {
var data = _compression != CompressionMethod.None
? _fragmentsBuffer.DecompressToArray (_compression)
: _fragmentsBuffer.ToArray ();
enqueueToMessageEventQueue (new MessageEventArgs (_fopcode, data));
}
_fragmentsBuffer = null;
_inContinuation = false;
}
return true;
}
private bool processFragmentedFrame(WebSocketFrame frame)
{
return frame.IsContinuation // Not first fragment
? true
: processFragments(frame);
}
private bool processPongFrame (WebSocketFrame frame)
{
_receivePong.Set ();
_logger.Trace ("Received a Pong.");
return true;
}
private bool processPingFrame(WebSocketFrame frame)
{
var mask = Mask.Unmask;
return true;
}
private bool processUnsupportedFrame (WebSocketFrame frame, CloseStatusCode code, string reason)
{
_logger.Debug ("An unsupported frame:" + frame.PrintToString (false));
processException (new WebSocketException (code, reason), null);
return false;
}
private bool processPongFrame(WebSocketFrame frame)
{
_receivePong.Set();
return true;
}
private string checkIfValidReceivedFrame (WebSocketFrame frame)
{
var masked = frame.IsMasked;
return _client && masked
? "A frame from the server is masked."
: !_client && !masked
? "A frame from a client isn't masked."
: _inContinuation && frame.IsData
? "A data frame has been received while receiving the fragmented data."
: frame.IsCompressed && _compression == CompressionMethod.None
? "A compressed frame is without an available decompression method."
: null;
}
private bool processUnsupportedFrame(WebSocketFrame frame, CloseStatusCode code, string reason)
{
processException(new WebSocketException(code, reason), null);
return false;
}
public bool MustSkip(WebSocketFrame frame) => false;
private bool processWebSocketFrame(WebSocketFrame frame)
{
return frame.IsCompressed && _compression == CompressionMethod.None
? processUnsupportedFrame(
frame,
CloseStatusCode.IncorrectData,
"A compressed data has been received without available decompression method.")
: frame.IsFragmented
? processFragmentedFrame(frame)
: frame.IsData
? processDataFrame(frame)
: frame.IsPing
? processPingFrame(frame)
: frame.IsPong
? processPongFrame(frame)
: frame.IsClose
? processCloseFrame(frame)
: processUnsupportedFrame(frame, CloseStatusCode.PolicyViolation, null);
}
