/// <summary>
/// 初始化协议驱动
/// </summary>
/// <param name="cmdAsmType">带命令驱动的程序集类型</param>
/// <param name="receiveFilter"></param>
public virtual void InitDriver(Type cmdAsmType, IReceiveFilter receiveFilter)
{
ReceiveFilter = receiveFilter;
this._Commands.Clear();
System.Reflection.Assembly asm = cmdAsmType.Assembly;
Type[] types = asm.GetTypes();
foreach (Type t in types)
{
if (typeof(IProtocolCommand).IsAssignableFrom(t))
{
if (t.Name != "IProtocolCommand" &&
t.Name != "ProtocolCommand" &&
!t.IsAbstract)
{
IProtocolCommand cmd = (IProtocolCommand)t.Assembly.CreateInstance(t.FullName);
if (cmd != null)
{
cmd.Setup(this);
_Commands.TryAdd(cmd.Name, cmd);
}
}
}
}
}
/// <summary>
/// 获得数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public IList <byte[]> Get(IReceiveFilter filter)
{
if (filter == null)
{
throw new NullReferenceException("filter引用为空");
}
if (DataLength <= 0)
{
return(new List <byte[]>());
}
lock (_SyncLock)
{
int lastByteOffset = InitOffset;
IList <byte[]> listBytes = filter.Filter(ReceiveBuffer, InitOffset, DataLength, ref lastByteOffset);
if (listBytes != null &&
listBytes.Count > 0 &&
lastByteOffset > InitOffset)
{
CurrentOffset = lastByteOffset + 1;
int gets = CurrentOffset - InitOffset;
DataLength -= gets;
MoveLeft(gets);
}
return(listBytes);
}
}
public RequestInfo Filter(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest)
{
rest = length;
var tag = readBuffer.ToHex((uint)offset, 1);
if (tag != "7e")
{
tag = readBuffer.ToHex((uint)offset, 2);
}
//if(tag=="7e")
//{
// var contextBuffer = new byte[length];
// Array.Copy(readBuffer,offset, contextBuffer, 0, contextBuffer.Length);
// return new RequestInfo(tag, contextBuffer);
//}
switch (tag)
{
case "7e":
NextReceiveFilter = defaultFilter;
break;
case "7878":
case "7979":
NextReceiveFilter = defaultFilter;
break;
}
return(null);
}
// Token: 0x06000712 RID: 1810 RVA: 0x00006180 File Offset: 0x00004380
public static BufferStream GetBufferStream <TStream, TPackageInfo>(this IReceiveFilter <TPackageInfo> receiveFilter, IList <ArraySegment <byte> > data) where TStream : BufferStream, new() where TPackageInfo : IPackageInfo
{
BufferStream current = BufferStream.GetCurrent <BufferStream>();
current.Initialize(data);
return(current);
}
protected override IReceiveFilter <StringPackageInfo> GetBodyReceiveFilter(HttpHeaderInfo header, int headerSize)
{
var session = AppContext.CurrentSession;
var websocketContext = new WebSocketContext(session, header);
var secWebSocketVersion = header.Get(WebSocketConstant.SecWebSocketVersion);
IReceiveFilter <StringPackageInfo> handshakeReceiveFilter = null;
if (secWebSocketVersion == RFC6455_VERSION)
{
handshakeReceiveFilter = new Rfc6455ReceiveFilter();
}
else if (secWebSocketVersion == HYBI10_VERSION)
{
handshakeReceiveFilter = new DraftHybi10ReceiveFilter();
}
else
{
handshakeReceiveFilter = new DraftHybi00ReceiveFilter();
}
var handshakeHandler = handshakeReceiveFilter as IHandshakeHandler;
if (handshakeHandler != null)
{
handshakeHandler.Handshake(session, header);
}
return(handshakeReceiveFilter);
}
// Token: 0x06000703 RID: 1795 RVA: 0x0001B534 File Offset: 0x00019734
public DefaultPipelineProcessor(IReceiveFilter <TPackageInfo> receiveFilter, int maxPackageLength = 0)
{
this.m_ReceiveFilter = receiveFilter;
this.m_FirstReceiveFilter = receiveFilter;
this.m_ReceiveCache = new BufferList();
this.m_MaxPackageLength = maxPackageLength;
}
/// <summary>
/// 内部读数据
/// </summary>
/// <param name="io"></param>
/// <param name="receiveFilter"></param>
/// <returns></returns>
private IList <byte[]> InternalReceive(IChannel io, IReceiveFilter receiveFilter)
{
List <byte[]> list = new List <byte[]>();
if (!this.Server.ServerConfig.StartReceiveDataFliter)
{
byte[] data = Receive(io);
if (data != null && data.Length > 0)
{
list.Add(data);
}
}
else
{
if (receiveFilter == null)
{
byte[] data = Receive(io);
if (data != null && data.Length > 0)
{
list.Add(data);
}
}
else
{
IList <byte[]> filterData = Receive(io, receiveFilter);
list.AddRange(filterData);
}
}
return(list);
}
/// <summary>
/// 接收数据接口
/// </summary>
/// <param name="io"></param>
/// <param name="receiveFilter"></param>
/// <returns></returns>
public virtual IList <byte[]> Receive(IChannel io, IReceiveFilter receiveFilter)
{
IList <byte[]> list = new List <byte[]>();
if (!io.Server.ServerConfig.StartReceiveDataFliter)
{
byte[] data = io.Read();
if (data != null && data.Length > 0)
{
list.Add(data);
}
}
else
{
if (receiveFilter == null)
{
byte[] data = io.Read();
if (data != null && data.Length > 0)
{
list.Add(data);
}
}
else
{
return(io.Read(receiveFilter));
}
}
return(list);
}
public DraftHybi00DataReceiveFilter(WebSocketContext context)
{
Context = context;
m_MarkReceiveFilter = new MarkReceiveFilter(this);
m_LenReceiveFilter = new LenReceiveFilter(this);
m_CloseMarkReceiveFilter = new CloseMarkReceiveFilter(this);
}
/// <summary>
/// Filters the request.
/// </summary>
/// <param name="readBuffer">The read buffer.</param>
/// <param name="offset">The offset.</param>
/// <param name="length">The length.</param>
/// <param name="toBeCopied">if set to <c>true</c> [to be copied].</param>
/// <param name="rest">The rest, the size of the data which has not been processed</param>
/// <param name="offsetDelta">return offset delta of next receiving buffer.</param>
/// <returns></returns>
TRequestInfo FilterRequest(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest, out int offsetDelta)
{
if (!AppServer.OnRawDataReceived(this, readBuffer, offset, length))
{
rest = 0;
offsetDelta = 0;
return(null);
}
var currentRequestLength = m_ReceiveFilter.LeftBufferSize;
var requestInfo = m_ReceiveFilter.Filter(readBuffer, offset, length, toBeCopied, out rest);
if (m_ReceiveFilter.State == FilterState.Error)
{
rest = 0;
offsetDelta = 0;
Close(CloseReason.ProtocolError);
requestInfo?.Dispose();
return(null);
}
var offsetAdapter = m_ReceiveFilter as IOffsetAdapter;
offsetDelta = offsetAdapter != null ? offsetAdapter.OffsetDelta : 0;
if (requestInfo == null)
{
//current buffered length
currentRequestLength = m_ReceiveFilter.LeftBufferSize;
}
else
{
//current request length
currentRequestLength = currentRequestLength + length - rest;
}
var maxRequestLength = GetMaxRequestLength();
if (currentRequestLength >= maxRequestLength)
{
if (Logger.IsErrorEnabled)
{
Logger.Error(this, string.Format("Max request length: {0}, current processed length: {1}", maxRequestLength, currentRequestLength));
}
Close(CloseReason.ProtocolError);
requestInfo?.Dispose();
return(null);
}
//If next Receive filter wasn't set, still use current Receive filter in next round received data processing
if (m_ReceiveFilter.NextReceiveFilter != null)
{
m_ReceiveFilter = m_ReceiveFilter.NextReceiveFilter;
}
return(requestInfo);
}
// Token: 0x060008D7 RID: 2263 RVA: 0x0001E1DC File Offset: 0x0001C3DC
public void Initialize <TPackageInfo>(IReceiveFilter <TPackageInfo> receiveFilter, Action <TPackageInfo> handler) where TPackageInfo : IPackageInfo
{
base.PipeLineProcessor = new DefaultPipelineProcessor <TPackageInfo>(receiveFilter, 0);
this.m_Handler = delegate(IPackageInfo p)
{
handler((TPackageInfo)((object)p));
};
}
//
#endregion 事件
#region 字段、属性
//
#region 命令
//
#endregion 命令
#endregion 字段、属性
#region 方法
public override void Initialize(IReceiveFilter <WpClientPackageInfo> receiveFilter)
{
base.Initialize(receiveFilter);
Connected += ConnectServer;
NewPackageReceived += ReceiveNewPackage;
Error += GetError;
Closed += CnnClose;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultPipelineProcessor{TPackageInfo}"/> class.
/// </summary>
/// <param name="packageHandler">The package handler.</param>
/// <param name="receiveFilter">The initializing receive filter.</param>
/// <param name="maxPackageLength">The max package size.</param>
/// <param name="bufferRecycler">The buffer recycler.</param>
public DefaultPipelineProcessor(IPackageHandler <TPackageInfo> packageHandler, IReceiveFilter <TPackageInfo> receiveFilter, int maxPackageLength = 0, IBufferRecycler bufferRecycler = null)
{
m_PackageHandler = packageHandler;
m_ReceiveFilter = receiveFilter;
m_BufferRecycler = bufferRecycler ?? s_NullBufferRecycler;
m_ReceiveCache = new BufferList();
m_MaxPackageLength = maxPackageLength;
}
/// <summary>
/// Gets a buffer reader instance which can be reused.
/// </summary>
/// <typeparam name="TReader">The type of the reader.</typeparam>
/// <typeparam name="TPackageInfo">The type of the package info.</typeparam>
/// <param name="receiveFilter">The receive filter.</param>
/// <param name="data">The buffer data source.</param>
/// <returns></returns>
public static IBufferReader GetBufferReader <TReader, TPackageInfo>(this IReceiveFilter <TPackageInfo> receiveFilter, IList <ArraySegment <byte> > data)
where TReader : BufferListReader, new()
where TPackageInfo : IPackageInfo
{
var reader = BufferListReader.GetCurrent <TReader>();
reader.Initialize(data);
return(reader);
}
internal void Initialize(AppServer appServer, ISocketSession socketSession)
{
AppServer = appServer;
SocketSession = socketSession;
SessionID = socketSession.SessionID;
m_Connected = true;
m_ReceiveFilter = new TerminatorReceiveFilter(new byte[] { (byte)'\r', (byte)'\n' });
socketSession.Initialize(this);
}
public void Reset()
{
m_ReceiveCache.Clear();
m_FirstReceiveFilter.Reset();
if (m_ReceiveFilter != m_FirstReceiveFilter)
{
m_ReceiveFilter = m_FirstReceiveFilter;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UdpSocketServer<TPackageInfo>"/> class.
/// </summary>
/// <param name="appServer">The app server.</param>
/// <param name="listeners">The listeners.</param>
public UdpSocketServer(IAppServer appServer, ListenerInfo[] listeners)
: base(appServer, listeners)
{
m_RequestHandler = appServer as IRequestHandler <TPackageInfo>;
m_IsUdpRequestInfo = typeof(IUdpPackageInfo).IsAssignableFrom(typeof(TPackageInfo));
m_UdpRequestFilter = ((IReceiveFilterFactory <TPackageInfo>)appServer.ReceiveFilterFactory).CreateFilter(appServer, null, null);
}
public IList <byte[]> Read(IReceiveFilter receiveFilter)
{
if (receiveFilter == null)
{
throw new NullReferenceException("receiveFilter为空");
}
return(ReceiveDataFilter(receiveFilter));
}
/// <summary>
/// Gets a buffer reader instance which can be reused.
/// </summary>
/// <typeparam name="TReader">The type of the reader.</typeparam>
/// <typeparam name="TPackageInfo">The type of the package info.</typeparam>
/// <param name="receiveFilter">The receive filter.</param>
/// <param name="data">The buffer data source.</param>
/// <returns></returns>
public static IBufferReader GetBufferReader <TReader, TPackageInfo>(this IReceiveFilter <TPackageInfo> receiveFilter, IList <ArraySegment <byte> > data)
where TReader : BufferListReader, new()
where TPackageInfo : IPackageInfo
{
//var reader = BufferListReader.GetCurrent<TReader>(); // don't use thread context for BufferListReader for now
var reader = new BufferListReader();
reader.Initialize(data);
return(reader);
}
public void Initialize <TPackageInfo>(IReceiveFilter <TPackageInfo> receiveFilter, Action <TPackageInfo> handler)
where TPackageInfo : IPackageInfo
{
PipeLineProcessor = new DefaultPipelineProcessor <TPackageInfo>(receiveFilter);
m_Handler = (p) => handler((TPackageInfo)p);
//
TimerCallback detecterDelegate = new TimerCallback(DetecterCallback);
SocketDetecterTimer = new Timer(detecterDelegate, null, 500, ConnectCheckInterval);
}
/// <summary>
/// Gets the buffer stream instance which can be reused.
/// </summary>
/// <typeparam name="TStream">The type of the stream.</typeparam>
/// <typeparam name="TPackageInfo">The type of the package info.</typeparam>
/// <param name="receiveFilter">The receive filter.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
public static BufferStream GetBufferStream <TStream, TPackageInfo>(this IReceiveFilter <TPackageInfo> receiveFilter, IList <ArraySegment <byte> > data)
where TStream : BufferStream, new()
where TPackageInfo : IPackageInfo
{
//var stream = new BufferStream();
var stream = BufferStream.GetCurrent <BufferStream>(); // don't use thread context for BufferListReader for now
stream.Initialize(data);
return(stream);
}
/// <summary>
/// 内部读数据
/// </summary>
/// <param name="io"></param>
/// <param name="receiveFilter"></param>
/// <returns></returns>
private IList <byte[]> InternalReceive(IChannel io, IReceiveFilter receiveFilter)
{
if (!this.Server.ServerConfig.StartReceiveDataFliter)
{
return(Receive(io, null));
}
else
{
return(Receive(io, receiveFilter));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UdpSocketServer<TRequestInfo>"/> class.
/// </summary>
/// <param name="appServer">The app server.</param>
/// <param name="listeners">The listeners.</param>
public UdpSocketServer(IAppServer appServer, ListenerInfo[] listeners)
: base(appServer, listeners)
{
m_RequestHandler = appServer as IRequestHandler <TRequestInfo>;
m_EndPointIPv4 = new IPEndPoint(IPAddress.Any, 0);
m_EndPointIPv6 = new IPEndPoint(IPAddress.IPv6Any, 0);
m_IsUdpRequestInfo = typeof(TRequestInfo).IsSubclassOf(typeof(UdpRequestInfo));
m_UdpRequestFilter = ((IReceiveFilterFactory <TRequestInfo>)appServer.ReceiveFilterFactory).CreateFilter(appServer, null, null);
}
public override bool Handshake(IWebSocketSession session, WebSocketReceiveFilterBase previousFilter, out IReceiveFilter<IWebSocketFragment> dataFrameReader)
{
if (!VersionTag.Equals(session.SecWebSocketVersion) && NextProcessor != null)
{
return NextProcessor.Handshake(session, previousFilter, out dataFrameReader);
}
dataFrameReader = null;
session.ProtocolProcessor = this;
if (!session.AppServer.ValidateHandshake(session, session.Items.GetValue<string>(OriginKey, string.Empty)))
return false;
var secWebSocketKey = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey, string.Empty);
if (string.IsNullOrEmpty(secWebSocketKey))
{
return false;
}
var responseBuilder = new StringBuilder();
string secKeyAccept = string.Empty;
try
{
secKeyAccept = Convert.ToBase64String(SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(secWebSocketKey + m_Magic)));
}
catch (Exception)
{
return false;
}
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseHeadLine10);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseUpgradeLine);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseConnectionLine);
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseAcceptLine, secKeyAccept);
var subProtocol = session.GetAvailableSubProtocol(session.Items.GetValue<string>(WebSocketConstant.SecWebSocketProtocol, string.Empty));
if (!string.IsNullOrEmpty(subProtocol))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseProtocolLine, subProtocol);
responseBuilder.AppendWithCrCf();
byte[] data = Encoding.UTF8.GetBytes(responseBuilder.ToString());
session.SendRawData(data, 0, data.Length);
dataFrameReader = new WebSocketDataFrameReceiveFilter();
return true;
}
public override TPackageInfo ResolvePackage(IBufferStream bufferStream)
{
int num = (int)bufferStream.Length;
string headerData = bufferStream.ReadString(num, HeaderEncoding);
HttpHeaderInfo header = new HttpHeaderInfo();
MimeHeaderHelper.ParseHttpHeader(headerData, header);
IReceiveFilter <TPackageInfo> bodyReceiveFilter = GetBodyReceiveFilter(header, num);
if (bodyReceiveFilter != null)
{
base.NextReceiveFilter = bodyReceiveFilter;
bufferStream.Clear();
return(default(TPackageInfo));
}
return(ResolveHttpPackageWithoutBody(header));
}
public override bool Handshake(IWebSocketSession session, WebSocketReceiveFilterBase previousFilter, out IReceiveFilter<IWebSocketFragment> dataFrameReader)
{
var secKey1 = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey1, string.Empty);
var secKey2 = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey2, string.Empty);
dataFrameReader = null;
if (string.IsNullOrEmpty(secKey1) && string.IsNullOrEmpty(secKey2) && NextProcessor != null)
{
return NextProcessor.Handshake(session, previousFilter, out dataFrameReader);
}
session.ProtocolProcessor = this;
if (!session.AppServer.ValidateHandshake(session, session.Items.GetValue<string>(WebSocketConstant.Origin, string.Empty)))
return false;
var secKey3 = session.Items.GetValue<byte[]>(WebSocketConstant.SecWebSocketKey3, m_ZeroKeyBytes);
var responseBuilder = new StringBuilder();
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseHeadLine00);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseUpgradeLine);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseConnectionLine);
if (!string.IsNullOrEmpty(session.Origin))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseOriginLine, session.Origin);
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseLocationLine, session.UriScheme, session.Host, session.Path);
var subProtocol = session.GetAvailableSubProtocol(session.Items.GetValue<string>(WebSocketConstant.SecWebSocketProtocol, string.Empty));
if (!string.IsNullOrEmpty(subProtocol))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseProtocolLine, subProtocol);
responseBuilder.AppendWithCrCf();
byte[] data = Encoding.UTF8.GetBytes(responseBuilder.ToString());
session.SendRawData(data, 0, data.Length);
//Encrypt message
byte[] secret = GetResponseSecurityKey(secKey1, secKey2, secKey3);
session.SendRawData(secret, 0, secret.Length);
dataFrameReader = new WebSocketDataReceiveFilter(previousFilter);
return true;
}
byte[] FilterRequest(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest, out int offsetDelta)
{
var currentRequestLength = m_ReceiveFilter.LeftBufferSize;
var requestInfo = m_ReceiveFilter.Filter(readBuffer, offset, length, toBeCopied, out rest);
if (m_ReceiveFilter.State == FilterState.Error)
{
rest = 0;
offsetDelta = 0;
return(null);
}
var offsetAdapter = m_ReceiveFilter as IOffsetAdapter;
offsetDelta = offsetAdapter != null ? offsetAdapter.OffsetDelta : 0;
if (requestInfo == null)
{
//current buffered length
currentRequestLength = m_ReceiveFilter.LeftBufferSize;
}
else
{
//current request length
currentRequestLength = currentRequestLength + length - rest;
}
var maxRequestLength = DefaultMaxRequestLength;
if (currentRequestLength >= maxRequestLength)
{
Logger.Error(string.Format("Max request length: {0}, current processed length: {1}", maxRequestLength, currentRequestLength));
return(null);
}
//If next Receive filter wasn't set, still use current Receive filter in next round received data processing
if (m_ReceiveFilter.NextReceiveFilter != null)
{
m_ReceiveFilter = m_ReceiveFilter.NextReceiveFilter;
}
return(requestInfo);
}
/// <summary>
/// Initializes the specified app session by AppServer and SocketSession.
/// </summary>
/// <param name="appServer">The app server.</param>
/// <param name="socketSession">The socket session.</param>
public virtual void Initialize(IAppServer<TAppSession, TRequestInfo> appServer, ISocketSession socketSession)
{
var castedAppServer = (AppServerBase<TAppSession, TRequestInfo>)appServer;
AppServer = castedAppServer;
Charset = castedAppServer.TextEncoding;
SocketSession = socketSession;
SessionID = socketSession.SessionID;
m_Connected = true;
m_ReceiveFilter = castedAppServer.ReceiveFilterFactory.CreateFilter(appServer, this, socketSession.RemoteEndPoint);
var filterInitializer = m_ReceiveFilter as IReceiveFilterInitializer;
if (filterInitializer != null)
filterInitializer.Initialize(castedAppServer, this);
socketSession.Initialize(this);
OnInit();
}
public DataPackageInfo Filter(BufferList data, out int rest)
{
rest = data.Total;
//according to the Setting,choose specified filter
if (false)
{
//fixed length filter
_fixedSizeReceiveFilter = new FixedSizeDataReceiveFilter(this, rest);
NextReceiveFilter = _fixedSizeReceiveFilter;
}
else
{
//Terminator Filter
NextReceiveFilter = _terminatorReceiveFilter;
}
return(null);
}
public override IList <byte[]> Read(IReceiveFilter receiveFilter)
{
System.Threading.Thread.Sleep(Server.ServerConfig.ComLoopInterval);
if (_ReceiveCache != null && _ReceiveCache.ReceiveBuffer != null)
{
if (_ReceiveCache.NextOffset >= _ReceiveCache.InitOffset + _ReceiveCache.Capacity)
{
_ReceiveCache.Reset();
}
int num = InternalRead(_ReceiveCache.ReceiveBuffer, _ReceiveCache.NextOffset, _ReceiveCache.InitOffset + _ReceiveCache.Capacity - _ReceiveCache.NextOffset);
if (num > 0)
{
_ReceiveCache.DataLength += num;
if (receiveFilter == null)
{
IList <byte[]> listBytes = new List <byte[]>();
listBytes.Add(_ReceiveCache.Get());
return(listBytes);
}
else
{
return(_ReceiveCache.Get(receiveFilter));
}
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public void Initialize <TPackageInfo>(IReceiveFilter <TPackageInfo> receiveFilter, Action <TPackageInfo> handler)
where TPackageInfo : IPackageInfo
{
PipeLineProcessor = new DefaultPipelineProcessor <TPackageInfo>(receiveFilter);
m_Handler = (p) => handler((TPackageInfo)p);
}
/// <summary>
/// Sets the next Receive filter which will be used when next data block received
/// </summary>
/// <param name="nextReceiveFilter">The next receive filter.</param>
protected void SetNextReceiveFilter(IReceiveFilter <TRequestInfo> nextReceiveFilter)
{
m_ReceiveFilter = nextReceiveFilter;
}
public bool Handshake(IWebSocketSession session, WebSocketReceiveFilterBase previousReader, out IReceiveFilter<IWebSocketFragment> dataFrameReader)
{
dataFrameReader = null;
session.SendRawData(m_SwitchResponse, 0, m_SwitchResponse.Length);
return true;
}
public abstract bool Handshake(IWebSocketSession session, WebSocketReceiveFilterBase previousFilter, out IReceiveFilter<IWebSocketFragment> dataFrameReader);
