542 lines
21 KiB
C#
542 lines
21 KiB
C#
// using System;
|
|
// using System.Collections.Generic;
|
|
// using System.Text;
|
|
// using System.Net;
|
|
// using System.Net.Sockets;
|
|
// using System.IO;
|
|
// //using BCG.Utilities;
|
|
// using BCG.Utilities.General;
|
|
// using System.Runtime.InteropServices;
|
|
|
|
// namespace BCG
|
|
// {
|
|
// /// <summary>
|
|
// /// This class, mantains a connection to a peer socket, using
|
|
// /// the .Net async TCP library. It sends heartbeats at regular
|
|
// /// intervals (config). It is in active states when messages
|
|
// /// are sent and received without an error state. It assumed
|
|
// /// dead state when either of the following happens
|
|
// /// BeginReceive returns a SocketError
|
|
// /// BeginSend returns a SocketError
|
|
// /// EndReceive returns a SocketError
|
|
// /// EndSend returns a SocketError
|
|
// /// As soon as it assumes dead state it stops sending or
|
|
// /// receiving any messages (including heartbeats).
|
|
// /// The user of this class can either detect that by
|
|
// /// missing heartbeats or checking the isConnected property.
|
|
// /// Missing should be the more general way, since if the
|
|
// /// peer dies in a 'silent' way, where none of the above
|
|
// /// methods indicate an error, missing heartbeats is guaranteed
|
|
// /// to detect it.
|
|
// /// </summary>
|
|
// public class AsyncTCPConnection : ITCPConnection, IWorker, IDisposable
|
|
// {
|
|
// /// <summary>
|
|
// /// This is used as a state for the Async send. Reason being
|
|
// /// that if onSend indicates that it could not send the full
|
|
// /// data (ie EndSend does not return the full size), the offset
|
|
// /// is used to resend the data
|
|
// /// </summary>
|
|
// public class AsyncMessage
|
|
// {
|
|
// public byte[] buffer;
|
|
// public int offset;
|
|
// public string messageId;
|
|
// public SendConfirmationDelegate onSendDel;
|
|
|
|
// public AsyncMessage(byte[] theBuffer, int theOffset)
|
|
// : this(theBuffer, theOffset, String.Empty, null) { }
|
|
|
|
// public AsyncMessage(byte[] theBuffer, int theOffset, string theMessageId, SendConfirmationDelegate theOnSendDel)
|
|
// {
|
|
// buffer = theBuffer;
|
|
// offset = theOffset;
|
|
// messageId = theMessageId;
|
|
// onSendDel = theOnSendDel;
|
|
// }
|
|
|
|
|
|
// public int length
|
|
// {
|
|
// get
|
|
// {
|
|
// return buffer.Length - offset;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// enum ReadState
|
|
// {
|
|
// readingSize,
|
|
// readingData
|
|
// };
|
|
|
|
// #region work around for .Net socket's LocalEndPoint bug
|
|
|
|
// [StructLayout(LayoutKind.Sequential)]
|
|
// private struct in_addr
|
|
// {
|
|
// [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
// public byte[] sin_addr;
|
|
// }
|
|
|
|
// [StructLayout(LayoutKind.Sequential)]
|
|
// private struct sockaddr
|
|
// {
|
|
// public short sin_family;
|
|
// public ushort sin_port;
|
|
// public in_addr sin_addr;
|
|
// [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
// public byte[] sin_zero;
|
|
// }
|
|
|
|
// [DllImport("wsock32.dll")]
|
|
// private static extern int getsockname(IntPtr s, ref sockaddr name, ref int namelen);
|
|
|
|
// [DllImport("wsock32.dll")]
|
|
// private static extern int getpeername(IntPtr s, ref sockaddr name, ref int namelen);
|
|
|
|
// #endregion
|
|
|
|
// private readonly int myMaxMessageSize = PubSub3Config.instance.PS3_MaxPacketSize;
|
|
// private RemoteConnectionInfo myPeer, mySelf;
|
|
// private Socket mySock;
|
|
// private ITCPMessageHandler myMessageHandler;
|
|
|
|
// private byte[] myCurrentReadBuffer;
|
|
// private int myCurrentReadBufferOffset;
|
|
// private ReadState myCurrentReadState;
|
|
|
|
// private bool myAlive = true;
|
|
|
|
// private byte[] myHBMessage;
|
|
// private TimeSpan myHBTimeSpan;
|
|
// private MasterWorker myMasterWorker = MasterWorker.getInstance(true);
|
|
// private bool myHBReceived = false, myDataReceived = false, myHBSent = false;
|
|
// private DateTime myLastHBReceivedTime = new DateTime(1900, 1, 1);
|
|
|
|
// public AsyncTCPConnection(Socket sock, TimeSpan heartBeatTimeSpan)
|
|
// {
|
|
// myHBTimeSpan = heartBeatTimeSpan;
|
|
// mySock = sock;
|
|
// mySock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, true);
|
|
// string ip;
|
|
// int port;
|
|
// getPeerAddress(out ip, out port);
|
|
// myPeer = new RemoteConnectionInfo(ip, port);
|
|
// getSelfAddress(out ip, out port);
|
|
// mySelf = new RemoteConnectionInfo(ip, port);
|
|
// // BlueEventLog.logEvent(String.Format("AsyncTCPConnection created : self = {0} , peer = {1}",
|
|
// // mySelf.ToString(), myPeer.ToString()), PS3LogLevels.connection);
|
|
// }
|
|
|
|
// public override string ToString()
|
|
// {
|
|
// return String.Format("peer = {0}, self = {1}", myPeer.ToString(), mySelf.ToString());
|
|
// }
|
|
|
|
// #region ITCPConnection Members
|
|
|
|
// public void sendWithConfirmation(byte[] data, ref string confId, SendConfirmationDelegate del)
|
|
// {
|
|
// confId = Guid.NewGuid().ToString();
|
|
// byte[] msg = myBuildDataMessage(data);
|
|
// myBeginOrResumeSending(new AsyncMessage(msg, 0, confId, del));
|
|
// }
|
|
|
|
// public void send(byte[] data)
|
|
// {
|
|
// byte[] msg = myBuildDataMessage(data);
|
|
// myBeginOrResumeSending(new AsyncMessage(msg, 0));
|
|
// }
|
|
|
|
// public void register(ITCPMessageHandler messageHandler)
|
|
// {
|
|
// // BlueEventLog.logAssert(myMessageHandler == null, "Message Handler is already assigned");
|
|
// // BlueEventLog.logEvent(String.Format("AsyncTCPConnection for peer = {0} being registered", myPeer.ToString()),
|
|
// // PS3LogLevels.connection);
|
|
// myMessageHandler = messageHandler;
|
|
// myMasterWorker.addWorker(this, myHBTimeSpan);
|
|
// myReadSize();
|
|
// }
|
|
|
|
// public void getPeerAddress(out string ip, out int port)
|
|
// {
|
|
// ip = "";
|
|
// port = 0;
|
|
// if (myAlive)
|
|
// {
|
|
// IPEndPoint ipEp = mySock.RemoteEndPoint as IPEndPoint;
|
|
// ip = ipEp.Address.ToString();
|
|
// port = ipEp.Port;
|
|
// }
|
|
// ///.Net has some problems getting the port, so using
|
|
// ///native code for that
|
|
// //sockaddr addr = new sockaddr();
|
|
// //int namelen = 16;
|
|
// //getsockname(mySock.Handle, ref addr, ref namelen);
|
|
// //port = addr.sin_port;
|
|
// }
|
|
|
|
// public void getSelfAddress(out string ip, out int port)
|
|
// {
|
|
// ip = "";
|
|
// port = 0;
|
|
// if (myAlive)
|
|
// {
|
|
// IPEndPoint ipEp = mySock.LocalEndPoint as IPEndPoint;
|
|
// ip = ipEp.Address.ToString();
|
|
// port = ipEp.Port;
|
|
// }
|
|
// ///due to this bug in .Net socket, we have to resort to
|
|
// ///native code
|
|
// //sockaddr addr = new sockaddr();
|
|
// //int namelen = 16;
|
|
// //getsockname(mySock.Handle, ref addr, ref namelen);
|
|
// //port = addr.sin_port;
|
|
// }
|
|
|
|
// public bool isDisposed
|
|
// {
|
|
// get { return !myAlive; }
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region IWorker Members
|
|
|
|
// bool _last_connected = false;
|
|
// public void doWork()
|
|
// {
|
|
// if (mySock != null)
|
|
// //if (mySock.Connected != _last_connected)
|
|
// {
|
|
// Console.WriteLine($"AsyncTCPConnection.doWork connected: {mySock.Connected}");
|
|
// _last_connected = mySock.Connected;
|
|
// }
|
|
// if (!myHBSent)
|
|
// {
|
|
// // BlueEventLog.logEvent(String.Format("Sending heartbeat to peer {0} for the first time", myPeer.ToString()),
|
|
// // PS3LogLevels.connection);
|
|
// myHBSent = true;
|
|
// }
|
|
// myBeginOrResumeSending(new AsyncMessage(myBuildHeartbeatMessage(), 0));
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region sending data
|
|
|
|
// private void myBeginOrResumeSending(AsyncMessage message)
|
|
// {
|
|
// if (myAlive)
|
|
// {
|
|
// try
|
|
// {
|
|
// //Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeSending len: {message.length} connected: {mySock.Connected}");
|
|
// SocketError beginSendErr;
|
|
// mySock.BeginSend(message.buffer, message.offset, message.length, SocketFlags.None,
|
|
// out beginSendErr, new AsyncCallback(myOnSend), message);
|
|
// Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeSending len: {message.length} socker_error: {beginSendErr} connected: {mySock.Connected}");
|
|
// if (beginSendErr != SocketError.Success)
|
|
// myHandleError(beginSendErr);
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// myHandleError(ex);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// private void myOnSend(IAsyncResult res)
|
|
// {
|
|
// if (myAlive)
|
|
// {
|
|
// try
|
|
// {
|
|
// SocketError writeErr;
|
|
// int bytesSent = mySock.EndSend(res, out writeErr);
|
|
// Console.WriteLine($"AsyncTCPConnection.myOnSend bytes: {bytesSent} writeErr: {writeErr} connected: {mySock.Connected}");
|
|
// AsyncMessage message = res.AsyncState as AsyncMessage;
|
|
// message.offset += bytesSent;
|
|
// if (writeErr == SocketError.Success)
|
|
// {
|
|
// if (message.offset == message.buffer.Length)
|
|
// {
|
|
// // if confirmation needs to be sent
|
|
// if (String.Empty != message.messageId)
|
|
// {
|
|
// message.onSendDel(message.messageId, true);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// ///resume writing rest of the message
|
|
// // BlueEventLog.logEvent("could not send the whole message all at once , messageSize = " +
|
|
// // message.buffer.Length + " offset = " + message.offset, PS3LogLevels.info);
|
|
// myBeginOrResumeSending(message);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// myHandleError(writeErr);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// myHandleError(ex);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// Assembles the heartbeat message, and uses it for
|
|
// /// future references
|
|
// /// </summary>
|
|
// /// <returns></returns>
|
|
// private byte[] myBuildHeartbeatMessage()
|
|
// {
|
|
// if (myHBMessage == null)
|
|
// {
|
|
// BinaryWriter bw = new BinaryWriter(new MemoryStream());
|
|
// int sz = 4;
|
|
// int msgType = 1;
|
|
// bw.Write(sz);
|
|
// bw.Write(msgType);
|
|
// myHBMessage = (bw.BaseStream as MemoryStream).ToArray();
|
|
// }
|
|
// return myHBMessage;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// Assembles the data message. This is necessary
|
|
// /// for the other side to understand the message. This can also
|
|
// /// be achieved by not forming the message and use the
|
|
// /// BeginSend (List<>) function rather than BeginSend (byte[])
|
|
// /// </summary>
|
|
// /// <param name="data"></param>
|
|
// /// <returns></returns>
|
|
// private byte[] myBuildDataMessage(byte[] data)
|
|
// {
|
|
// BinaryWriter bw = new BinaryWriter(new MemoryStream());
|
|
// bw.Write(data.Length + 8);
|
|
// bw.Write(0);
|
|
// bw.Write(0); ///mid for backward compatibility
|
|
// bw.Write(data);
|
|
// return (bw.BaseStream as MemoryStream).ToArray();
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region receiving data
|
|
|
|
// private void myReadSize()
|
|
// {
|
|
// myCurrentReadBuffer = new byte[4];
|
|
// myCurrentReadBufferOffset = 0;
|
|
// myCurrentReadState = ReadState.readingSize;
|
|
// myBeginOrResumeReading();
|
|
// }
|
|
|
|
// private void myReadData(int dataSize)
|
|
// {
|
|
// myCurrentReadBuffer = new byte[dataSize];
|
|
// myCurrentReadBufferOffset = 0;
|
|
// myCurrentReadState = ReadState.readingData;
|
|
// myBeginOrResumeReading();
|
|
// }
|
|
|
|
// private void myBeginOrResumeReading()
|
|
// {
|
|
// if (myAlive)
|
|
// {
|
|
// try
|
|
// {
|
|
// int beginReceiveAttempts = 0;
|
|
// while (true)
|
|
// {
|
|
// beginReceiveAttempts++;
|
|
// SocketError readSockErr;
|
|
// mySock.BeginReceive(myCurrentReadBuffer, myCurrentReadBufferOffset,
|
|
// myCurrentReadBuffer.Length - myCurrentReadBufferOffset,
|
|
// SocketFlags.None, out readSockErr,
|
|
// new AsyncCallback(myOnRead),
|
|
// myCurrentReadBuffer);
|
|
// Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeReading socket_error: {readSockErr} connected: {mySock.Connected}");
|
|
// if (readSockErr == SocketError.NoBufferSpaceAvailable)
|
|
// {
|
|
// string msg = String.Format("Not enough buffer space to receive {0} bytes. Attempt: {1} of {2}.",
|
|
// myCurrentReadBuffer.Length - myCurrentReadBufferOffset,
|
|
// beginReceiveAttempts, PubSub3Config.instance.PS3_retriesOnNoBufferSpace + 1);
|
|
// //BlueEventLog.logEvent(msg, PS3LogLevels.disconnection);
|
|
|
|
// if (beginReceiveAttempts < (PubSub3Config.instance.PS3_retriesOnNoBufferSpace + 1))
|
|
// System.Threading.Thread.Sleep(PubSub3Config.instance.PS3_millisecondsBetweenNoBufferSpaceRetries);
|
|
// else
|
|
// {
|
|
// //BlueEventLog.logEvent("Could not recover from NoBufferSpace condition. Breaking connection.", PS3LogLevels.disconnection);
|
|
// myHandleError(readSockErr);
|
|
// }
|
|
// }
|
|
// else if (readSockErr == SocketError.Success)
|
|
// {
|
|
// if (beginReceiveAttempts > 1)
|
|
// // BlueEventLog.logEvent(String.Format("Recovered from NoBufferSpace after {0} tries",beginReceiveAttempts-1) ,
|
|
// // PS3LogLevels.disconnection);
|
|
// break;
|
|
// }
|
|
// else
|
|
// myHandleError(readSockErr);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// myHandleError(ex);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// private void myOnRead(IAsyncResult res)
|
|
// {
|
|
// if (myAlive)
|
|
// {
|
|
// try
|
|
// {
|
|
// SocketError readErr;
|
|
// Console.WriteLine($"AsyncTCPConnection.myOnRead pre connected: {mySock.Connected}");
|
|
// int bytesRead = mySock.EndReceive(res, out readErr);
|
|
// Console.WriteLine($"AsyncTCPConnection.myOnRead bytes: {bytesRead} readErr: {readErr} connected: {mySock.Connected}");
|
|
// myCurrentReadBufferOffset += bytesRead;
|
|
// if (readErr == SocketError.Success)
|
|
// {
|
|
// if (myCurrentReadBufferOffset == myCurrentReadBuffer.Length)
|
|
// {
|
|
// ///read the whole of the buffer
|
|
// if (myCurrentReadState == ReadState.readingSize)
|
|
// {
|
|
// ///the size has already been read, now convert
|
|
// ///it into an int, and start reading the data
|
|
// int dataSize = new BinaryReader(new MemoryStream(myCurrentReadBuffer)).ReadInt32();
|
|
// if (dataSize > myMaxMessageSize)
|
|
// {
|
|
// string errMessage = "Encountered malformed message, size indicated = " + dataSize;
|
|
// //BlueEventLog.logEvent(errMessage, "Error");
|
|
// myHandleError(new ApplicationException(errMessage));
|
|
// }
|
|
// else
|
|
// myReadData(dataSize);
|
|
// }
|
|
// else
|
|
// {
|
|
// ///the whole data has been finally read, time to
|
|
// ///tell the subscriber about it
|
|
// BinaryReader br = new BinaryReader(new MemoryStream(myCurrentReadBuffer));
|
|
// int msgType = br.ReadInt32();
|
|
// if (msgType == 0)
|
|
// {
|
|
// ///skips the message ID
|
|
// br.ReadInt32();
|
|
// byte[] data = br.ReadBytes(myCurrentReadBuffer.Length - 8);
|
|
// ///callbacks can be made through thread pool to avoid this
|
|
// ///thread from being blocked, by this callback
|
|
// if (!myDataReceived)
|
|
// {
|
|
// myDataReceived = true;
|
|
// Console.WriteLine($"AsyncTCPConnection Data received for the first time from peer {myPeer.ToString()}");
|
|
// }
|
|
// myMessageHandler.onData(new RemoteMessage(data, RemoteMessageType.Data, myPeer));
|
|
|
|
// }
|
|
// else if (msgType == 1)
|
|
// {
|
|
// if (!myHBReceived)
|
|
// {
|
|
// myHBReceived = true;
|
|
// Console.WriteLine($"AsyncTCPConnection HB received for the first time from peer {myPeer.ToString()}");
|
|
// }
|
|
// myLastHBReceivedTime = DateTime.Now;
|
|
// myMessageHandler.onData(new RemoteMessage(null, RemoteMessageType.Heartbeat, myPeer));
|
|
// }
|
|
// myReadSize();
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// ///still part of the buffer left to read
|
|
// ///continue reading
|
|
// myBeginOrResumeReading();
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// myHandleError(readErr);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// myHandleError(ex);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// #region IDisposable Members
|
|
|
|
// public void Dispose()
|
|
// {
|
|
// Console.WriteLine("AsyncTCPConnection.Dispose()");
|
|
// lock (this)
|
|
// {
|
|
// if (myAlive)
|
|
// {
|
|
// myMasterWorker.removeWorker(this);
|
|
// myAlive = false;
|
|
// // BlueEventLog.logEvent(String.Format("AsycnTCPConnection with peer {0} being disposed, last HB was received at {1}" ,
|
|
// // myPeer.ToString(), myLastHBReceivedTime.ToLongTimeString()),
|
|
// // PS3LogLevels.disconnection);
|
|
// try
|
|
// {
|
|
// mySock.Close();
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// String.Format("Exception of type {0} thrown while trying to close socket connected to {1} , with" +
|
|
// " the following exception msg {2}", ex.GetType().ToString(), myPeer.ToString(), ex.Message);
|
|
// //BlueEventLog.logEvent(ex);
|
|
// if (ex is OutOfMemoryException)
|
|
// throw ex;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// #endregion
|
|
|
|
// private void myHandleError(object err)
|
|
// {
|
|
// lock (this)
|
|
// {
|
|
// string errMsg = "";
|
|
// if (err is Exception)
|
|
// {
|
|
// errMsg = String.Format("AsyncTCPConnection.Dispose Encountered an exception of type '{0}' on the socket connected to ip = {1} , port = {2} ; " +
|
|
// "Exception message = {3} , if the socket has not been disposed, it will be disposed now", err.GetType(), myPeer.ip, myPeer.port, (err as Exception).Message);
|
|
// if (err is OutOfMemoryException)
|
|
// throw (err as OutOfMemoryException);
|
|
// }
|
|
// else if (err is SocketError)
|
|
// {
|
|
// errMsg = String.Format("AsyncTCPConnection.Dispose Encountered a SocketError of type '{0}' on the socket connected to ip = {1} , port = {2} ; " +
|
|
// "if the socket has not been disposed, it will be disposed now", err.ToString(), myPeer.ip, myPeer.port);
|
|
// Console.WriteLine($"AsyncTCPConnection.myHandleError errMsg: {errMsg}");
|
|
// }
|
|
// //BlueEventLog.logEvent(errMsg, PS3LogLevels.disconnection);
|
|
// if (myAlive)
|
|
// {
|
|
// Dispose();
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// } |