internal void SendPacketBinary(byte[] aBinaryData, int aFragmentSize)
{
if (!aFragmentSize.Equals(-1))
{
if (aFragmentSize <= WebSocketConstants.DEFAULT_MAX_FRAME_SIZE)
{
SendfragmentsBinary(aBinaryData, aFragmentSize);
}
else
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE);
}
OnError(new WebSocketError(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE));
throw new WebSocketException(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE
+ WebSocketMessage.SEPARATOR + WebSocketConstants.DEFAULT_MAX_FRAME_SIZE);
}
}
else
{
if (aBinaryData.Length > WebSocketConstants.DEFAULT_MAX_FRAME_SIZE)
{
SendfragmentsBinary(aBinaryData, WebSocketConstants.DEFAULT_MAX_FRAME_SIZE);
}
else
{
IWebSocketPacket lPacket = new WebSocketPacket(WebSocketFrameType.BINARY, aBinaryData);
lPacket.IsFragmented = true;
SendInternal(WebSocketProtocolAbstraction.RawToProtocolPacket(lPacket));
}
}
}
internal void SendPacketText(string aUTF8String, int aFragmentSize)
{
if (!aFragmentSize.Equals(-1))
{
if (aFragmentSize <= WebSocketConstants.DEFAULT_MAX_FRAME_SIZE)
{
SendFragmentsText(aUTF8String, aFragmentSize);
}
else
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE);
}
OnError(new WebSocketError(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE));
throw new WebSocketException(WebSocketMessage.FRAGMENT_SIXE_EXCEED_MAX_SIZE
+ WebSocketMessage.SEPARATOR + WebSocketConstants.DEFAULT_MAX_FRAME_SIZE);
}
}
else
{
if (aUTF8String.Length > WebSocketConstants.DEFAULT_MAX_FRAME_SIZE)
{
SendFragmentsText(aUTF8String, WebSocketConstants.DEFAULT_MAX_FRAME_SIZE);
}
else
{
IWebSocketPacket lPacket = new WebSocketPacket(WebSocketFrameType.TEXT, aUTF8String);
lPacket.IsFragmented = true;
SendInternal(WebSocketProtocolAbstraction.RawToProtocolPacket(lPacket));
}
}
}
internal void SendFragmentsText(string aUTF8String, int aFragmentSize)
{
StringBuilder lBuild = new StringBuilder(aUTF8String);
int lBuildSize = lBuild.Length;
int lFragmentCount = CalcFragmentCount(lBuildSize, aFragmentSize);
int lCurrentFragment = 1;
int lPos = 0;
while (lPos < lBuildSize)
{
if (lPos + aFragmentSize > lBuildSize)
{
aFragmentSize = lBuildSize - lPos;
}
IWebSocketPacket lPacket;
if (lCurrentFragment.Equals(1))
{
lPacket = new WebSocketPacket(WebSocketFrameType.TEXT,
lBuild.ToString(lPos, aFragmentSize));
}
else if (lCurrentFragment.Equals(lFragmentCount))
{
lPacket = new WebSocketPacket(WebSocketFrameType.FRAGMENT,
lBuild.ToString(lPos, aFragmentSize));
lPacket.IsFragmented = true;
}
else
{
lPacket = new WebSocketPacket(WebSocketFrameType.FRAGMENT,
lBuild.ToString(lPos, aFragmentSize));
}
SendInternal(WebSocketProtocolAbstraction.RawToProtocolPacket(lPacket));
if (lPos + aFragmentSize > lBuildSize)
{
lPos += lBuildSize - lPos;
}
else
{
lPos += aFragmentSize;
}
lCurrentFragment++;
Thread.Sleep((aFragmentSize * 1) / 100);
}
}
internal void SendPacket(IWebSocketPacket aPacket)
{
try
{
lock (mWriteLock)
SendInternal(WebSocketProtocolAbstraction.RawToProtocolPacket(aPacket));
}
catch (Exception)
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.ERROR_WHILE_SENDING_SOCKET);
}
OnError(new WebSocketError(WebSocketMessage.ERROR_WHILE_SENDING_SOCKET));
StopIt();
}
}
internal void SendfragmentsBinary(byte[] aBinaryData, int aFragmentSize)
{
byte[] lNewBinaryData = new byte[aFragmentSize];
int lBinaryDataSize = aBinaryData.Length;
int lFragmentCount = CalcFragmentCount(lBinaryDataSize, aFragmentSize);
int lCurrentFragment = 1;
int lPos = 0;
while (lPos < lBinaryDataSize)
{
if (lPos + aFragmentSize > lBinaryDataSize)
{
aFragmentSize = lBinaryDataSize - lPos;
lNewBinaryData = new byte[aFragmentSize];
}
Array.Copy(aBinaryData, lPos, lNewBinaryData, 0, aFragmentSize);
IWebSocketPacket lPacket;
if (lCurrentFragment.Equals(1))
{
lPacket = new WebSocketPacket(WebSocketFrameType.BINARY, lNewBinaryData);
}
else if (lCurrentFragment.Equals(lFragmentCount))
{
lPacket = new WebSocketPacket(WebSocketFrameType.FRAGMENT, lNewBinaryData);
lPacket.IsFragmented = true;
}
else
{
lPacket = new WebSocketPacket(WebSocketFrameType.FRAGMENT, lNewBinaryData);
}
SendInternal(WebSocketProtocolAbstraction.RawToProtocolPacket(lPacket));
if (lPos + aFragmentSize > lBinaryDataSize)
{
lPos += lBinaryDataSize - lPos;
}
else
{
lPos += aFragmentSize;
}
lCurrentFragment++;
Thread.Sleep((aFragmentSize * 1) / 100);
}
}
private void ProcessHybi()
{
WebSocketFrameType lFrameType;
IWebSocketPacket lPacket;
while (mIsRunning)
{
try
{
lPacket = WebSocketProtocolAbstraction.protocolToRawPacket(mNetStream);
Console.WriteLine(lPacket.GetString());
lFrameType = (lPacket != null ? lPacket.FrameType : WebSocketFrameType.INVALID);
if (lFrameType.Equals(null))
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.NULL_FRAME_TYPE);
}
mIsRunning = false;
mCLose = WebSocketCloseReason.BROKEN;
OnError(new WebSocketError(WebSocketMessage.NULL_FRAME_TYPE, mCLose));
}
else if (lFrameType.Equals(WebSocketFrameType.INVALID))
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.INVALID_HYBI_FRAME);
}
mIsRunning = false;
mCLose = WebSocketCloseReason.BROKEN;
OnError(new WebSocketError(WebSocketMessage.INVALID_HYBI_FRAME, mCLose));
}
else if (lFrameType.Equals(WebSocketFrameType.CLOSE))
{
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.CLOSE_FRAME_TYPE);
}
mIsRunning = false;
mCLose = WebSocketCloseReason.CLIENT;
StopIt();
}
else if (lFrameType.Equals(WebSocketFrameType.PONG))
{
OnRecivePong();
if (WebSocketStateOfStatus.isWritable(mStatus))
{
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.PING_PACKET_SENDING);
}
Ping();
OnSendPing();
}
}
else if (lFrameType.Equals(WebSocketFrameType.BINARY))
{
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.BINARY_PACKET_RECEIVED);
}
//****TODO****
}
else if (lFrameType.Equals(WebSocketFrameType.TEXT))
{
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.TEXT_PACKET_RECEIVED);
}
OnReciveTextPacket(this, lPacket);
}
else if (lFrameType.Equals(WebSocketFrameType.FRAGMENT))
{
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.FRAGMENT_PACKET_RECEIVED);
}
//****TODO****
}
}
catch (Exception lEx)
{
mIsRunning = false;
if (mStatus.Equals(WebSocketStatus.CLOSED))
{
mCLose = WebSocketCloseReason.CLIENT;
}
else
{
mCLose = WebSocketCloseReason.BROKEN;
OnError(new WebSocketError(WebSocketMessage.ERROR_HYBI_PROCESSOR, mCLose));
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.ERROR_HYBI_PROCESSOR
+ WebSocketMessage.SEPARATOR + lEx.Message);
}
}
}
}
}
