private void WaitForMessage_Body_Callback(IAsyncResult ar)
{
if (m_SocketWorker.Connected)
{
SocketStateHolder holder = (SocketStateHolder)ar.AsyncState;
byte[] header = holder.Header;
byte[] body = holder.Body;
int rcvByteCount = m_SocketWorker.EndReceive(ar);
System.Diagnostics.Debug.Print("{0}: WaitForMessage_Body_Callback [ByteCount: {1}]",
m_ConnectProcedure, rcvByteCount);
holder.RecvStartIndex += rcvByteCount;
if (holder.RecvStartIndex == body.Length)
{
byte[] data = new byte[header.Length + body.Length];
Array.Copy(header, 0, data, 0, header.Length);
Array.Copy(body, 0, data, header.Length, body.Length);
//process secs message
ProcessInCommingMessage(data);
//continue to next message
WaitForMessage_Header_New(holder.Socket);
}
else
{
WaitForMessage_Body(holder.Socket, header, body, holder.RecvStartIndex);
}
}
}
private void WaitForMessage_Header(Socket sck, byte[] header, int headerStartIndex)
{
Debug.Print("WaitForMessage_Header overload 1");
if (sck.Connected)
{
SocketStateHolder holder = new SocketStateHolder();
holder.Socket = sck;
holder.Header = header;
holder.RecvStartIndex = headerStartIndex;
SocketError se;
try
{
sck.BeginReceive(header, headerStartIndex, header.Length - headerStartIndex,
SocketFlags.None, out se, WaitForMessage_Header_Callback, holder);
}
catch (ObjectDisposedException)
{
if (m_KeepAlive)
{
ContinueMakeConnection();
}
}
}
}
private void WaitForMessage_Body(Socket sck, byte[] header, byte[] body, int bodyStartIndex)
{
if (sck.Connected)
{
System.Diagnostics.Debug.Print("{0}: WaitForMessage_Body {1}, {2}, {3}",
m_ConnectProcedure, header.Length, body.Length, bodyStartIndex);
SocketError se;
SocketStateHolder holder = new SocketStateHolder();
holder.Socket = sck;
holder.Header = header;
holder.Body = body;
holder.RecvStartIndex = bodyStartIndex;
m_SocketWorker.BeginReceive(body, bodyStartIndex, body.Length - bodyStartIndex, SocketFlags.None,
out se, WaitForMessage_Body_Callback, holder);
if (se == SocketError.ConnectionReset)
{
//Start();
//let T8 work
}
}
//let the timer does its job
//else
//{
// Start();
//}
}
private void WaitForMessage_Header(Socket sck, byte[] header, int headerStartIndex)
{
//was stop
if (sck == null && m_State == HsmsState.NOT_CONNECTED)
{
return;
}
if (sck.Connected)
{
SocketStateHolder holder = new SocketStateHolder();
holder.Socket = sck;
holder.Header = header;
holder.RecvStartIndex = headerStartIndex;
SocketError se;
System.Diagnostics.Debug.Print("{0}: WaitForMessage_Header {1}, {2}",
m_ConnectProcedure, header.Length, headerStartIndex);
sck.BeginReceive(header, headerStartIndex, header.Length - headerStartIndex,
SocketFlags.None, out se, WaitForMessage_Header_Callback, holder);
if (se == SocketError.ConnectionReset)
{
Start();
}
}
else
{
Start();
}
}
private void WaitForMessage_Header(Socket sck, byte[] header, int headerStartIndex)
{
//was stop
if (sck == null || m_State == HsmsState.NOT_CONNECTED)
{
return;
}
if (sck.Connected)
{
SocketStateHolder holder = new SocketStateHolder();
holder.Socket = sck;
holder.Header = header;
holder.RecvStartIndex = headerStartIndex;
SocketError se;
try
{
sck.BeginReceive(header, headerStartIndex, header.Length - headerStartIndex,
SocketFlags.None, out se, WaitForMessage_Header_Callback, holder);
}
catch (ObjectDisposedException)
{
ContinueMakeConnection();
}
}
}
private void WaitForMessage_Body_Callback(IAsyncResult ar)
{
Debug.Print("WaitForMessage_Body_Callback");
SocketStateHolder holder = (SocketStateHolder)ar.AsyncState;
Socket sck = holder.Socket;
//***********************
int rcvByteCount = 0;
try
{
rcvByteCount = sck.EndReceive(ar);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.ConnectionReset)
{
if (m_KeepAlive)
{
ContinueMakeConnection();
}
}
return;
}
catch (ObjectDisposedException)
{
if (m_KeepAlive)
{
ContinueMakeConnection();
}
return;
}
byte[] header = holder.Header;
byte[] body = holder.Body;
holder.RecvStartIndex += rcvByteCount;
if (holder.RecvStartIndex == body.Length)
{
byte[] data = new byte[header.Length + body.Length];
Array.Copy(header, 0, data, 0, header.Length);
Array.Copy(body, 0, data, header.Length, body.Length);
//keep log
WriteHsmsLog(data, DirectionType.Recv);
//process secs message
ProcessSecsMessageBytes(data);
//continue to next message
WaitForMessage_Header(holder.Socket);
}
else
{
WaitForMessage_Body(holder.Socket, header, body, holder.RecvStartIndex);
}
}
private void WaitForMessage_Body(Socket sck, byte[] header, byte[] body, int bodyStartIndex)
{
if (sck.Connected)
{
SocketError se;
SocketStateHolder holder = new SocketStateHolder();
holder.Socket = sck;
holder.Header = header;
holder.Body = body;
holder.RecvStartIndex = bodyStartIndex;
sck.BeginReceive(body, bodyStartIndex, body.Length - bodyStartIndex, SocketFlags.None,
out se, WaitForMessage_Body_Callback, holder);
}
}
public HomeController(SocketStateHolder socketStateHolder)
{
_socketStateHolder = socketStateHolder;
}
public WebSocketConnectionManager(SocketStateHolder socketStateHolder)
{
_socketStateHolder = socketStateHolder;
}
private void WaitForMessage_Header_Callback(IAsyncResult ar)
{
Debug.Print("WaitForMessage_Header_Callback");
SocketStateHolder holder = (SocketStateHolder)ar.AsyncState;
Socket sck = holder.Socket;
int byteCount = 0;
try
{
byteCount = sck.EndReceive(ar);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.ConnectionReset)
{
if (m_KeepAlive)
{
ContinueMakeConnection();
}
}
return;
}
catch (ObjectDisposedException)
{
if (m_KeepAlive)
{
ContinueMakeConnection();
}
return;
}
if (byteCount == 0)
{
return;
}
byte[] header = holder.Header;
holder.RecvStartIndex += byteCount;
if (holder.RecvStartIndex == header.Length)
{
SType sType = (SType)header[9];
bool needBody = false;
uint bodyByteCount = 0;
if (sType == SType.Message)
{
byte[] lbb = new byte[4];
Array.Copy(header, 0, lbb, 0, 4);
Array.Reverse(lbb);
bodyByteCount = BitConverter.ToUInt32(lbb, 0) - 10; //exclude header
needBody = (bodyByteCount > 0); //header
}
if (needBody)
{
byte[] body = new byte[bodyByteCount];
WaitForMessage_Body(sck, header, body, 0);
}
else
{
//keep hsms log file
WriteHsmsLog(header, DirectionType.Recv);
//case of completed message and control message
switch (sType)
{
case SType.Message:
ProcessSecsMessageBytes(header);
break;
case SType.SelectReq:
if (m_Parameters.Mode == HsmsConnectProcedure.PASSIVE)
{
ChangeHsmsState(HsmsState.SELECTED);
//stop T7
T7_Timer_Stop();
//Select.Req relate with T5
SendSelectReponse(header);
}
break;
case SType.SelectResp:
if (m_Parameters.Mode == HsmsConnectProcedure.ACTIVE)
{
ChangeHsmsState(HsmsState.SELECTED);
//T6 timer
T6_Timer_Stop();
//start link test timer
LinkTest_Timer_Start();
}
break;
case SType.LinktestReq:
SendLinkTestResponse(header);
break;
case SType.LinktestResp:
//T6 timer stop
T6_Timer_Stop();
//l
LinkTest_Timer_Start();
break;
case SType.SeparateReq:
if (m_KeepAlive)
{
ContinueMakeConnection();
}
break;
default:
//unknow
break;
}
WaitForMessage_Header(sck);
}
}
else
{
WaitForMessage_Header(sck, header, holder.RecvStartIndex);
}
holder.Socket = null;
holder.Header = null;
holder.Body = null;
holder = null;
}
private void WaitForMessage_Header_Callback(IAsyncResult ar)
{
SocketStateHolder holder = (SocketStateHolder)ar.AsyncState;
Socket sck = holder.Socket;
System.Diagnostics.Debug.Print("{0}: WaitForMessage_Header_Callback Connected={1}",
m_ConnectProcedure, sck.Connected);
if (sck.Connected)
{
byte[] header = holder.Header;
int byteCount = 0;
try
{
byteCount = sck.EndReceive(ar);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.ConnectionReset)
{
return;
}
}
if (byteCount == 0)
{
return;
}
holder.RecvStartIndex += byteCount;
System.Diagnostics.Debug.Print("{0}: WaitForMessage_Header_Callback [ByteCount: {1}]",
m_ConnectProcedure, byteCount);
if (holder.RecvStartIndex == header.Length)
{
byte sType = header[9];
uint bodyByteCount = 0;
switch (sType)
{
case 0: //message
byte[] lbb = new byte[4];
Array.Copy(header, 0, lbb, 0, 4);
Array.Reverse(lbb);
bodyByteCount = BitConverter.ToUInt32(lbb, 0) - 10; //exclude header
bool needBody = (bodyByteCount > 0); //header
if (needBody)
{
byte[] body = new byte[bodyByteCount];
WaitForMessage_Body(sck, header, body, 0);
return;
}
else
{
//process secs message
ProcessInCommingMessage(header);
}
break;
case 1: //Select.Req
m_State = HsmsState.SELECTED;
//stop T7
T7_Timer_Stop();
//Select.Req relate with T5
SendSelectReponse(header);
//raise event
RaiseEventOnSelected();
break;
case 2: //Select.Resp
m_State = HsmsState.SELECTED;
//T6 timer
T6_Timer_Stop();
//start link test timer
LinkTest_Timer_Start();
//raise event
RaiseEventOnSelected();
break;
case 5: //Linktest.Req
SendLinkTestResponse(header);
break;
case 6: //Linktest.Resp
//T6 timer stop
T6_Timer_Stop();
//l
LinkTest_Timer_Start();
break;
case 9: //Separate.Req
m_State = HsmsState.NOT_CONNECTED;
break;
default:
//unknow
break;
}
WaitForMessage_Header_New(sck);
//** be careful when added more code below this section
//** because at " case 0: //message" have the "return;" statement
//** that might cause somethings go wrong
}
else
{
WaitForMessage_Header(sck, header, holder.RecvStartIndex);
}
}
//let the timer does its job
//else
//{
// Start();
//}
holder.Socket = null;
holder.Header = null;
holder.Body = null;
holder = null;
}
