private bool Connect()
{
bool result = false;
try
{
Socket tcpClient = null;
IPAddress[] hostAddresses = Dns.GetHostAddresses(_Host);
foreach (IPAddress address in hostAddresses)
{
if ((address.AddressFamily == AddressFamily.InterNetwork) || (address.AddressFamily == AddressFamily.InterNetworkV6))
{
tcpClient = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpClient.Connect(address, _Port);
tcpClient.NoDelay = true;
break;
}
}
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = tcpClient;
SocketError socketError;
tcpClient.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
_TCPClient = tcpClient;
result = true;
}
catch
{
}
return(result);
}
private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
{
Socket listener = (Socket)sender;
Socket client = null;
do
{
try
{
client = e.AcceptSocket;
}
catch (Exception ex)
{
Trace.WriteLine(TTracePriority.High, ex.ToString());
}
if (client != null)
{
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.StartReceive = DateTime.Now;
SocketAsyncEventArgs parameters = new SocketAsyncEventArgs();
parameters.UserToken = stateObject;
parameters.SetBuffer(stateObject.Buffer, 0, ReceiveStateObject.BufferSize);
parameters.Completed += ReceiveCompleted;
if (!client.ReceiveAsync(parameters))
{
ReceiveCompleted(client, parameters);
}
}
e.AcceptSocket = null;
} while (!listener.AcceptAsync(e));
}
private void Callback_OnReceive(IAsyncResult result)
{
try
{
ReceiveStateObject obj = (ReceiveStateObject)result.AsyncState;
int recvBytes = _socket.EndReceive(result);
if (0 == recvBytes)
{
Close();
return;
}
obj.buffer.writeIndex += recvBytes;
ReceiveEvent evt = new ReceiveEvent();
evt.session = this;
evt.buffer = obj.buffer;
eventQueue.Enqueue(evt);
Receive();
}
catch (System.Exception error)
{
Error(error);
}
}
private void ReadCallback(IAsyncResult ar)
{
ReceiveStateObject state = (ReceiveStateObject)ar.AsyncState;
Socket handler = state.workSocket;
try
{
int bytesRead = handler.EndReceive(ar);
if (0 < bytesRead)
{
string strPing = Encoding.UTF8.GetString(state.buffer);
SendMessage(handler, state.strParkID, true, strPing);
//OnMessageEvent(new MessageEventArgs(strPing, true));
}
if (handler.Connected)
{
handler.BeginReceive(state.buffer, 0, ReceiveStateObject.BufferSize, 0, asyncReceive, state);
}
}
catch (Exception e)
{
OnMessageEvent(new MessageEventArgs(CommonFunction.GetExceptionMessage(e).ToString(), true));
}
}
private void DoAcceptCallback(IAsyncResult asyncResult)
{
Socket listener = (Socket)asyncResult.AsyncState;
Socket client = null;
try
{
if (!_Terminate)
{
client = listener.EndAccept(asyncResult);
}
}
catch (Exception ex)
{
ApplicationEventLog.WriteEntry(ex.ToString(), System.Diagnostics.EventLogEntryType.Error);
}
if (!_Terminate)
{
listener.BeginAccept(new AsyncCallback(DoAcceptCallback), listener);
}
if (client != null)
{
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = client;
SocketError socketError;
stateObject.StartReceive = DateTime.Now;
client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, new AsyncCallback(DoReceiveCallback), stateObject);
}
}
private void AsyncAcceptCB(IAsyncResult iResult)
{
try
{
Socket objListener = (Socket)iResult.AsyncState;
byte[] parkIDBuffer;
Int32 nTransferSize = 0;
Socket peerSocket = objListener.EndAccept(out parkIDBuffer, out nTransferSize, iResult);
string strExtra = "Connected";
string strParkID = Encoding.UTF8.GetString(parkIDBuffer, 0, nTransferSize);
StringBuilder builder = new StringBuilder();
builder.AppendFormat("Accept to receive data【{0} Size = {1}】", strParkID, nTransferSize);
OnMessageEvent(new MessageEventArgs(builder.ToString(), true));
if (nParkIDSize <= nTransferSize)
{
strParkID = Encoding.UTF8.GetString(parkIDBuffer, 0, nParkIDSize);
lock (this)
if (peerSocks.ContainsKey(strParkID))
{
Socket peer = GetPeerSocket(strParkID);
if (null != peer)
{
peer.Close();
}
peerSocks.Remove(strParkID);
strExtra += "【Remove existence】";
}
peerSocket.ReceiveTimeout = 1000;
peerSocket.SendTimeout = 2000;
peerSocks.Add(strParkID, peerSocket);
ReceiveStateObject state = new ReceiveStateObject();
state.workSocket = peerSocket;
state.strParkID = strParkID;
peerSocket.BeginReceive(state.buffer, 0, ReceiveStateObject.BufferSize, 0, asyncReceive, state);
SendMessage(peerSocket, strParkID, true, strExtra);
}
if (objListener.IsBound)
{
objListener.BeginAccept(nParkIDSize, asyncAccept, objListener);
}
}
catch (Exception e)
{
OnMessageEvent(new MessageEventArgs(CommonFunction.GetExceptionMessage(e).ToString(), true));
}
}
private void Receive()
{
try
{
ReceiveStateObject obj = new ReceiveStateObject();
obj.socket = _socket;
obj.buffer = new Gamnet.Buffer();
_socket.BeginReceive(obj.buffer.buffer, 0, Gamnet.Buffer.BUFFER_SIZE, 0, new AsyncCallback(Callback_OnReceive), obj);
}
catch (System.Exception error)
{
Error(error);
Close();
}
}
private void ReceiveCallback(System.IAsyncResult ar)
{
ReceiveStateObject state = (ReceiveStateObject)ar.AsyncState;
int bytesreceived = state.sock.EndReceive(ar);
if (bytesreceived != state.BufferSize)
{
throw new System.Exception("Failed to get an entire response!");
}
byte[] buff = state.buffer;
WiimoteInfo info = new WiimoteInfo();
info.FromBytes(buff);
StateMutex.WaitOne();
Wiimotes[info.Name] = info;
StateMutex.ReleaseMutex();
wiimoteSocket.BeginReceive(state.buffer, 0, state.BufferSize, 0, new System.AsyncCallback(ReceiveCallback), state);
}
private static void Receive(Socket client)
{
ReceiveDone = new ManualResetEventSlim(false);
try
{
// Create the state object.
ReceiveStateObject state = new ReceiveStateObject {
workSocket = client
};
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, ReceiveStateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket
// from the asynchronous state object.
ReceiveStateObject state = (ReceiveStateObject)ar.AsyncState;
Socket client = state.workSocket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
string value = Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
state.sb.Append(value);
// Get the rest of the data.
Console.WriteLine("Got so far:\n" + value);
ProcessMessageString(value);
// else
// {
// Console.WriteLine("Getting More data. ");
// client.BeginReceive(state.buffer, 0, ReceiveStateObject.BufferSize, 0, ReceiveCallback, state);
// }
}
else
{
// state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// All the data has arrived; put it in response.
if (state.sb.Length > 1)
{
_response = state.sb.ToString();
}
// Signal that all bytes have been received.
ReceiveDone.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private void ReceiveCallback(System.IAsyncResult ar)
{
ReceiveStateObject state = (ReceiveStateObject)ar.AsyncState;
byte[] buff = state.buffer;
try{
Body_ b = new Body_();
b.FromBytes(buff);
//Debug.Log ("Received " + b.name + " translation, (x,y,z)=" + b.translation.x + "," + b.translation.y + "," + b.translation.z + "\n");
StateMutex.WaitOne();
Bodies_[b.name] = b;
StateMutex.ReleaseMutex();
}
catch (Exception ex)
{
Debug.Log("Caught: " + ex.Message);
}
viconSocket.BeginReceive(state.buffer, 0, state.BufferSize, 0, new System.AsyncCallback(ReceiveCallback), state);
}
void Start()
{
wiimoteSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
IPHostEntry ipHostInfo = Dns.GetHostEntry(WiimoteServerIP);
IPAddress ipAddress = ipHostInfo.AddressList[0];
System.IAsyncResult result = wiimoteSocket.BeginConnect(ipAddress, WiimoteServerPort, null, null);
result.AsyncWaitHandle.WaitOne(1000, true);
if (!wiimoteSocket.Connected)
{
wiimoteSocket.Close();
Destroy(this);
return;
}
ReceiveStateObject state = new ReceiveStateObject();
state.sock = wiimoteSocket;
state.BufferSize = WiimoteInfo.BufferSize;
state.buffer = new byte[state.BufferSize];
wiimoteSocket.BeginReceive(state.buffer, 0, state.BufferSize, 0, new System.AsyncCallback(ReceiveCallback), state);
}
void Start()
{
// START EDITABLE SECTION: Here we declare a body adjustment for each Vicon tracker to address Blade's limitations for creating objects
// Adjustment for RiftDK1
Body_ RiftDK1 = new Body_();
RiftDK1.name = "RiftDK1";
RiftDK1.translation.x = -0.022f;
RiftDK1.translation.y = -0.095f;
RiftDK1.translation.z = -0.018f;
RiftDK1.euler.h = 342.5f;
RiftDK1.euler.p = 347.0f;
RiftDK1.euler.r = 196.5f;
BodyAdjustments_[RiftDK1.name] = RiftDK1;
// Adjustment for RightGlove
Body_ RightGlove = new Body_();
RightGlove.name = "RightGlove";
RightGlove.translation.x = 0f;
RightGlove.translation.y = 0f;
RightGlove.translation.z = 0f;
RightGlove.euler.h = 87.83496f;
RightGlove.euler.p = 7.07246f;
RightGlove.euler.r = 86.11337f;
BodyAdjustments_[RightGlove.name] = RightGlove;
// Adjustment for RightWiimote
Body_ RightWiimote = new Body_();
RightWiimote.name = "RightWiimote";
RightWiimote.translation.x = 0f;
RightWiimote.translation.y = 0f;
RightWiimote.translation.z = 0f;
RightWiimote.euler.h = 90f;
RightWiimote.euler.p = 5f;
RightWiimote.euler.r = 90f;
BodyAdjustments_[RightWiimote.name] = RightWiimote;
// Adjustment for LeftGlove
Body_ LeftGlove = new Body_();
LeftGlove.name = "LeftGlove";
LeftGlove.translation.x = 0f;
LeftGlove.translation.y = 0f;
LeftGlove.translation.z = 0f;
LeftGlove.euler.h = 86.82818f;
LeftGlove.euler.p = 359.3969f;
LeftGlove.euler.r = 271.8313f;
BodyAdjustments_[LeftGlove.name] = LeftGlove;
// Adjustment for LeftWiimote
Body_ LeftWiimote = new Body_();
LeftWiimote.name = "LeftWiimote";
LeftWiimote.translation.x = 0f;
LeftWiimote.translation.y = 0f;
LeftWiimote.translation.z = 0f;
LeftWiimote.euler.h = 90f;
LeftWiimote.euler.p = -10f;
LeftWiimote.euler.r = 74f;
BodyAdjustments_[LeftWiimote.name] = LeftWiimote;
// Adjustment for RightShoe
Body_ RightShoe = new Body_();
RightShoe.name = "RightShoe";
RightShoe.translation.x = 0.0f;
RightShoe.translation.y = -0.015f;
RightShoe.translation.z = 0.0f;
RightShoe.euler.h = 232.4361f;
RightShoe.euler.p = 18.79926f;
RightShoe.euler.r = 112.5233f;
BodyAdjustments_ [RightShoe.name] = RightShoe;
// Adjustment for LeftShoe
Body_ LeftShoe = new Body_();
LeftShoe.name = "LeftShoe";
LeftShoe.translation.x = 0.0f;
LeftShoe.translation.y = -0.005f;
LeftShoe.translation.z = 0.0f;
LeftShoe.euler.h = 310.6974f;
LeftShoe.euler.p = 17.13592f;
LeftShoe.euler.r = 255.4526f;
BodyAdjustments_ [LeftShoe.name] = LeftShoe;
// END EDITABLE SECTION
viconSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
//Debug.Log ("Trying to open a connection to: " + ViconServerIP);
IPAddress ipAddress;
IPAddress.TryParse(ViconServerIP, out ipAddress);
System.IAsyncResult result = viconSocket.BeginConnect(ipAddress, ViconServerPort, null, null);
result.AsyncWaitHandle.WaitOne(1000, true);
if (!viconSocket.Connected)
{
//Debug.Log ("Closing the socket");
viconSocket.Close();
Destroy(this);
return;
}
ReceiveStateObject state = new ReceiveStateObject();
state.sock = viconSocket;
state.BufferSize = Body_.BufferSize;
state.buffer = new byte[state.BufferSize];
viconSocket.BeginReceive(state.buffer, 0, state.BufferSize, 0, new System.AsyncCallback(ReceiveCallback), state);
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
{
Socket client = (Socket)sender;
ReceiveStateObject stateObject = e.UserToken as ReceiveStateObject;
try
{
int readCount = e.BytesTransferred;
bool continueReceive = true;
if (readCount > 0)
{
string text = Encoding.ASCII.GetString(stateObject.Buffer, 0, readCount);
stateObject.Data.Append(text);
if (text.Contains("|"))
{
string data = stateObject.Data.ToString();
int count = 0;
while (!string.IsNullOrEmpty(data))
{
int index = data.IndexOf("|");
if (index == -1)
{
break;
}
else
{
count += (index + 1);
string table = data.Substring(0, index);
index++;
if (index < data.Length)
{
data = data.Substring(index);
}
else
{
data = null;
}
string id = null;
string[] fields = table.Split(',');
int fieldLength = fields.Length;
if (fields[0] == BROADCAST_PURGE_NOTIFICATION)
{
bool purge = false;
if (fieldLength >= 3)
{
if (!bool.TryParse(fields[2], out purge))
{
purge = false;
}
if (fieldLength >= 4)
{
id = fields[3];
}
}
if (fieldLength >= 4)
{
BusinessLogicFactory.NotificationOrchestrator.SendChangeNotification(fields[1], purge, id);
}
}
else if (fields[0] == BROADCAST_NOTIFICATION)
{
if (fieldLength >= 4)
{
id = fields[3];
}
if (fieldLength >= 4)
{
BusinessLogicFactory.NotificationOrchestrator.SendChangeNotification(fields[1], false, id);
}
}
else if (fields[0] == SETUP_NOTIFICATION)
{
if (fieldLength >= 2)
{
BusinessLogicFactory.NotificationOrchestrator.AddNotifcationClient(fields[1], client);
}
}
}
}
stateObject.Data.Remove(0, count);
}
}
else
{
if (client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
if (!client.ReceiveAsync(e))
{
ReceiveCompleted(sender, e);
}
}
else
{
#if DEBUG
ApplicationEventLog.WriteEntry("Flow", string.Format("DBNotificationTCPServer::DoReceiveCallback: closing client socket {0}", client), System.Diagnostics.EventLogEntryType.Information);
#endif
client.Close();
}
}
#pragma warning disable 168
catch (Exception ex)
#pragma warning restore 168
{
#if DEBUG
ApplicationEventLog.WriteEntry("Flow", string.Format("DBNotificationTCPServer::DoReceiveCallback: Exception\n{0}", ex), System.Diagnostics.EventLogEntryType.Error);
#endif
}
}
private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
{
Socket listener = (Socket)sender;
Socket client = null;
do
{
try
{
client = e.AcceptSocket;
}
catch (Exception ex)
{
Trace.WriteLine(TTracePriority.High, ex.ToString());
}
if (client != null)
{
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.StartReceive = DateTime.Now;
SocketAsyncEventArgs parameters = new SocketAsyncEventArgs();
parameters.UserToken = stateObject;
parameters.SetBuffer(stateObject.Buffer, 0, ReceiveStateObject.BufferSize);
parameters.Completed += ReceiveCompleted;
if (!client.ReceiveAsync(parameters))
ReceiveCompleted(client, parameters);
}
e.AcceptSocket = null;
} while (!listener.AcceptAsync(e));
}
private static void Receive(Socket client)
{
ReceiveDone = new ManualResetEventSlim(false);
try
{
// Create the state object.
ReceiveStateObject state = new ReceiveStateObject {workSocket = client};
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, ReceiveStateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
ReceiveStateObject stateObject = asyncResult.AsyncState as ReceiveStateObject;
try
{
int readCount = stateObject.Client.EndReceive(asyncResult);
bool continueReceive = true;
if (readCount > 0)
{
stateObject.Data.Write(stateObject.Buffer, 0, readCount);
if ((stateObject.RequestLength == 0) && (stateObject.Data.Length >= 4))
{
long position = stateObject.Data.Position;
stateObject.Data.Position = 0;
int requestLength = NetworkByteOrderConverter.ToInt32(stateObject.Data);
stateObject.RequestLength = Math.Abs(requestLength) + 4;
stateObject.Error = requestLength < 0;
stateObject.Data.Position = position;
}
if (stateObject.RequestLength == stateObject.Data.Position)
{
_ErrorResponse = stateObject.Error;
_ResponseBytes = new byte[stateObject.RequestLength - 4];
stateObject.Data.Position = 4;
stateObject.Data.Read(_ResponseBytes, 0, _ResponseBytes.Length);
stateObject.Data.Position = 0;
stateObject.Data.SetLength(0);
stateObject.RequestLength = 0;
_ResponseWaitHandle.Set();
}
}
else
{
if (stateObject.Client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < stateObject.Client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
SocketError socketError;
stateObject.Client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
}
else
{
_Connected = false;
_ResponseWaitHandle.Set();
stateObject.Client.Close();
}
}
#pragma warning disable 168
catch (Exception ex)
#pragma warning restore 168
{
_Connected = false;
_ResponseWaitHandle.Set();
stateObject.Client.Close();
}
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
ReceiveStateObject stateObject = asyncResult.AsyncState as ReceiveStateObject;
try
{
int readCount = stateObject.Client.EndReceive(asyncResult);
bool continueReceive = true;
if (readCount > 0)
{
string text = Encoding.ASCII.GetString(stateObject.Buffer, 0, readCount);
#if UNITTEST_DEBUG
string logFileName = System.IO.Path.Combine(_LogFolder, string.Format("ReceiveMessage_{0:yyyyMMdd}.log", DateTime.Now));
StringBuilder sb = new StringBuilder();
sb.AppendFormat(string.Format("RX {0:yyyyMMdd_HHmmss.fffff} {1}\r\n", DateTime.Now, text));
lock (this)
{
System.IO.File.AppendAllText(logFileName, sb.ToString());
}
#endif
stateObject.Data.Append(text);
if (text.Contains("\n"))
{
string data = stateObject.Data.ToString();
int count = 0;
while (!string.IsNullOrEmpty(data))
{
int index = data.IndexOf("\n");
if (index == -1)
{
// partial message - break out and get the rest in the following response
//count = 0;
break;
}
else
{
count += (index + 1);
string message = data.Substring(0, index);
ProcessMessage(message);
index++;
if (index < data.Length)
{
data = data.Substring(index);
}
else
{
data = null;
}
}
}
if (count > 0)
{
stateObject.Data.Remove(0, count);
}
}
}
else
{
if (stateObject.Client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < stateObject.Client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
SocketError socketError;
stateObject.Client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
}
else
{
ApplicationEventLog.WriteEntry("Flow", string.Format("DALChangeNotification::ReceiveCallback continueReceive false - Reconnecting to serve {0} port {1}", stateObject.NotificationServer.ServerName, stateObject.NotificationServer.Port), EventLogEntryType.Error);
stateObject.NotificationServer.Connected = false;
stateObject.Client.Close();
Connect(stateObject.NotificationServer, true);
}
}
catch (Exception ex)
{
ApplicationEventLog.WriteEntry("Flow", string.Format("DALChangeNotification::ReceiveCallback Exception\n{0}", ex), EventLogEntryType.Error);
stateObject.NotificationServer.Connected = false;
stateObject.Client.Close();
Connect(stateObject.NotificationServer, true);
}
}
/// <summary>
/// Sets up the state object and then calls the BeginReceive method to
/// read the data from the client socket asynchronously.
/// </summary>
/// <param name="client">The socket</param>
private void receive(Socket client)
{
try
{
// Create the state object.
ReceiveStateObject state = new ReceiveStateObject();
state.socket = client;
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, ReceiveStateObject.BUFFER_SIZE, 0,
new AsyncCallback(receiveCallback), state);
}
catch (Exception e)
{
handleException(e);
}
}
private bool Connect()
{
bool result = false;
try
{
Socket tcpClient = null;
IPAddress[] hostAddresses = Dns.GetHostAddresses(_Host);
foreach (IPAddress address in hostAddresses)
{
if ((address.AddressFamily == AddressFamily.InterNetwork) || (address.AddressFamily == AddressFamily.InterNetworkV6))
{
tcpClient = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpClient.Connect(address, _Port);
tcpClient.NoDelay = true;
break;
}
}
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = tcpClient;
SocketError socketError;
tcpClient.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
_TCPClient = tcpClient;
result = true;
}
catch
{
}
return result;
}
private void DoAcceptCallback(IAsyncResult asyncResult)
{
Socket listener = (Socket)asyncResult.AsyncState;
Socket client = null;
try
{
if (!_Terminate)
client = listener.EndAccept(asyncResult);
}
catch (Exception ex)
{
ApplicationEventLog.WriteEntry(ex.ToString(), System.Diagnostics.EventLogEntryType.Error);
}
if (!_Terminate)
listener.BeginAccept(new AsyncCallback(DoAcceptCallback), listener);
if (client != null)
{
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = client;
SocketError socketError;
stateObject.StartReceive = DateTime.Now;
client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, new AsyncCallback(DoReceiveCallback), stateObject);
}
}
private bool Connect(NotificationServer notificationServer, bool autoRepair)
{
bool connected = false;
//NotificationServer result = null;
DateTime timeOutTime = DateTime.Now.AddSeconds(5);
while (!connected && DateTime.Now < timeOutTime)
{
try
{
Socket tcpClient = null;
IPAddress[] hostAddresses = Dns.GetHostAddresses(notificationServer.ServerName);
foreach (IPAddress address in hostAddresses)
{
if ((address.AddressFamily == AddressFamily.InterNetwork)) // || (address.AddressFamily == AddressFamily.InterNetworkV6)
{
tcpClient = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpClient.Connect(address, notificationServer.Port);
tcpClient.NoDelay = true;
break;
}
}
if (tcpClient != null)
{
notificationServer.TcpClient = tcpClient;
notificationServer.Connected = true;
if (notificationServer.TableChangeClients.Count > 0)
{
StringBuilder tables = new StringBuilder();
for (int index = 0; index < notificationServer.TableChangeClients.Count; index++)
{
tables.Append(SETUP_NOTIFICATION);
tables.Append(notificationServer.TableChangeClients[index].TableName);
tables.Append("|");
}
byte[] buffer = Encoding.ASCII.GetBytes(tables.ToString());
tcpClient.Send(buffer);
}
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = tcpClient;
stateObject.NotificationServer = notificationServer;
SocketError socketError;
tcpClient.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
}
connected = true;
}
catch
{
}
if (!connected)
{
System.Threading.Thread.Sleep(500);
}
}
if (!connected)
{
lock (notificationServer)
{
notificationServer.Connected = false;
notificationServer.AllowConnectionAfter = DateTime.Now.AddSeconds(10);
AddNotificationToRepair(notificationServer.TableChangeClients);
notificationServer.TableChangeClients.Clear();
if (autoRepair)
{
lock (_NotificationServersToReconnect)
{
_NotificationServersToReconnect.Add(notificationServer);
}
_TriggerNotificationRepair.Set();
}
}
}
return(connected);
}
private void DoReceiveCallback(IAsyncResult asyncResult)
{
ReceiveStateObject stateObject = asyncResult.AsyncState as ReceiveStateObject;
try
{
int readCount = stateObject.Client.EndReceive(asyncResult);
bool continueReceive = true;
if (readCount > 0)
{
stateObject.Data.Write(stateObject.Buffer, 0, readCount);
if ((stateObject.RequestLength == 0) && (stateObject.Data.Length > 4))
{
long position = stateObject.Data.Position;
stateObject.Data.Position = 0;
stateObject.RequestLength = NetworkByteOrderConverter.ToInt32(stateObject.Data) + 4;
stateObject.Data.Position = position;
}
if (stateObject.RequestLength == stateObject.Data.Position)
{
stateObject.Data.Position = 4;
IPCRequest request = IPCRequest.Deserialise(stateObject.Data);
ThreadPool.QueueUserWorkItem(new WaitCallback((s) => { ProcessRequest(stateObject.Client, request); }));
stateObject.Data.Position = 0;
stateObject.Data.SetLength(0);
stateObject.RequestLength = 0;
}
}
else
{
if (stateObject.Client.ReceiveTimeout <= 0)
{
continueReceive = false;
}
else
{
TimeSpan diff = DateTime.Now.Subtract(stateObject.StartReceive);
if (diff.TotalMilliseconds < stateObject.Client.ReceiveTimeout)
{
continueReceive = false;
}
}
}
if (continueReceive)
{
stateObject.StartReceive = DateTime.Now;
SocketError socketError;
stateObject.Client.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, new AsyncCallback(DoReceiveCallback), stateObject);
}
else
{
stateObject.Client.Close();
}
}
#pragma warning disable 0168
catch (Exception ex)
#pragma warning restore 0168
{
stateObject.Client.Close();
}
}
private bool Connect(NotificationServer notificationServer, bool autoRepair)
{
bool connected = false;
//NotificationServer result = null;
DateTime timeOutTime = DateTime.Now.AddSeconds(5);
while (!connected && DateTime.Now < timeOutTime)
{
try
{
Socket tcpClient = null;
IPAddress[] hostAddresses = Dns.GetHostAddresses(notificationServer.ServerName);
foreach (IPAddress address in hostAddresses)
{
if ((address.AddressFamily == AddressFamily.InterNetwork)) // || (address.AddressFamily == AddressFamily.InterNetworkV6)
{
tcpClient = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpClient.Connect(address, notificationServer.Port);
tcpClient.NoDelay = true;
break;
}
}
if (tcpClient != null)
{
notificationServer.TcpClient = tcpClient;
notificationServer.Connected = true;
if (notificationServer.TableChangeClients.Count > 0)
{
StringBuilder tables = new StringBuilder();
for (int index = 0; index < notificationServer.TableChangeClients.Count; index++)
{
tables.Append(SETUP_NOTIFICATION);
tables.Append(notificationServer.TableChangeClients[index].TableName);
tables.Append("|");
}
byte[] buffer = Encoding.ASCII.GetBytes(tables.ToString());
tcpClient.Send(buffer);
}
ReceiveStateObject stateObject = new ReceiveStateObject();
stateObject.Client = tcpClient;
stateObject.NotificationServer = notificationServer;
SocketError socketError;
tcpClient.BeginReceive(stateObject.Buffer, 0, ReceiveStateObject.BufferSize, SocketFlags.None, out socketError, _ReceiveCallback, stateObject);
}
connected = true;
}
catch
{
}
if (!connected)
System.Threading.Thread.Sleep(500);
}
if (!connected)
{
lock (notificationServer)
{
notificationServer.Connected = false;
notificationServer.AllowConnectionAfter = DateTime.Now.AddSeconds(10);
AddNotificationToRepair(notificationServer.TableChangeClients);
notificationServer.TableChangeClients.Clear();
if (autoRepair)
{
lock (_NotificationServersToReconnect)
{
_NotificationServersToReconnect.Add(notificationServer);
}
_TriggerNotificationRepair.Set();
}
}
}
return connected;
}
