private void CloseCallback(object closingStateObject)
{
var closingState = (ClosingState)closingStateObject;
// Stop reading process (if any)
try
{
this.BaseSocket.ReadStop();
}
catch (Exception exception)
{
closingState.RegisterException(exception);
}
// Clear receive state and free the receive buffer
var state = this.receiveState;
this.receiveState = null;
// Return acquired buffer to the pool
state?.Buffer?.Dispose();
// Shut down any writing operations
// Handle will be closed after the shutdown process
var shutdownRequest = new UvShutdownRequest(this.BaseSocket, this.ShutdownCallback, closingState);
try
{
shutdownRequest.Shutdown();
}
catch (Exception exception)
{
this.ShutdownCallback(shutdownRequest, exception, closingState);
}
}
public StreamEngine(AsyncSocket handle, Options options, string endpoint)
{
m_handle = handle;
m_insize = 0;
m_ioEnabled = false;
m_sendingState = SendState.Idle;
m_receivingState = ReceiveState.Idle;
m_outsize = 0;
m_session = null;
m_options = options;
m_plugged = false;
m_endpoint = endpoint;
m_socket = null;
m_encoder = null;
m_decoder = null;
m_actionsQueue = new Queue <StateMachineAction>();
// Set the socket buffer limits for the underlying socket.
if (m_options.SendBuffer != 0)
{
m_handle.SendBufferSize = m_options.SendBuffer;
}
if (m_options.ReceiveBuffer != 0)
{
m_handle.ReceiveBufferSize = m_options.ReceiveBuffer;
}
}
/// <summary>
/// Disconnect network
/// </summary>
public virtual void OnDisConnected()
{
KDCommon.Log("SessionID:" + sessionID + " Client Offline" + "，在线人数：" + CacheSvc.Instance.GetOnlineServerSessions().Count);
LoginSys.Instance.ClearOfflineData(this);
SendState.Dispose();
ReceiveState.Dispose();
}
public void ReadData(Server server)
{
if (ReadDataInner(server))
while (data.Count >= ExpectLength)
{
var bytes = PopBytes(ExpectLength);
switch (State)
{
case ReceiveState.Header:
{
ExpectLength = BitConverter.ToInt32(bytes, 0) - 4;
Frame = BitConverter.ToInt32(bytes, 4);
State = ReceiveState.Data;
if (ExpectLength < 0 || ExpectLength > MaxOrderLength)
{
server.DropClient(this);
Log.Write("server", "Dropping client {0} for excessive order length = {1}", PlayerIndex, ExpectLength);
return;
}
} break;
case ReceiveState.Data:
{
server.DispatchOrders(this, Frame, bytes);
MostRecentFrame = Frame;
ExpectLength = 8;
State = ReceiveState.Header;
} break;
}
}
}
void OnAccept(IAsyncResult asyncResult)
{
Socket clientSocket = null;
try
{
clientSocket = listenSocket.EndAccept(asyncResult);
// Wait for next client
this.listenSocket.BeginAccept(OnAccept, null);
IPEndPoint clientIp = (IPEndPoint)clientSocket.RemoteEndPoint;
Console.WriteLine("Connection from {0}.{1}", clientIp.Address, clientIp.Port);
ReceiveState receiveState = new ReceiveState
{
ClientSocket = clientSocket,
Buffer = new byte[4],
Offset = 0,
Count = 4,
ReceivingLength = true,
};
clientSocket.BeginReceive(receiveState.Buffer, 0, 4, SocketFlags.None, OnReceive, receiveState);
}
catch (ObjectDisposedException)
{
// socket closed
}
catch (SocketException e)
{
Console.WriteLine("Socket exception: {0}", e);
}
}
private void ReceiveAsync(ClientSocket clientSocket)
{
Socket socket = clientSocket.Socket;
if (!socket.Connected)
{
return;
}
ReceiveState readBuff = clientSocket.ReceiveState;
try {
int count = socket.Receive(readBuff.Stream.GetBuffer(), (int)readBuff.Stream.Position,
(int)(readBuff.Stream.Length - readBuff.Stream.Position), SocketFlags.None);
readBuff.Stream.Position += count;
if (count <= 0)
{
CloseClient(clientSocket);
return;
}
OnReceiveData(clientSocket);
}
catch (Exception exception) {
Debug.LogError("客户端连接问题：" + exception);
CloseClient(clientSocket);
//throw;
}
}
//解析我们的信息
void OnReceiveData(ClientSocket clientSocket)
{
ReceiveState readbuff = clientSocket.ReceiveState;
if (readbuff.Stream.Position < readbuff.Stream.Length) //未接收满包头或包体
{
return;
}
readbuff.Stream.Position = 0L;
bool processSuccess = false;
if (readbuff.PacketHeader != null)
{
processSuccess = ProcessPacket(clientSocket);
}
else
{
processSuccess = ProcessPacketHeader(clientSocket);
}
if (processSuccess)
{
//ReceiveAsync(clientSocket);
return;
}
}
public static JamPacket Receive(SslStream stream)
{
const int RECEIVE_TIMEOUT = 2000;
ReceiveState state = new ReceiveState()
{
Stream = stream,
Packet = new JamPacket(),
HeaderBuffer = new byte[Marshal.SizeOf(typeof(JamPacketHeader))],
ReceiveCompleted = new AutoResetEvent(false)
};
try
{
stream.BeginRead(state.HeaderBuffer, 0, state.HeaderBuffer.Length, ReceiveHeaderCallback, state);
if (Debugger.IsAttached)
{
state.ReceiveCompleted.WaitOne();
}
else
{
state.ReceiveCompleted.WaitOne(RECEIVE_TIMEOUT);
}
}
catch (IOException) { }
if (state.Packet.Header.DataType == 0)
{
return(null);
}
state.Packet.ContainsData = true;
return(state.Packet);
}
private static void ReceiveAsync(IAsyncResult ar)
{
ReceiveState state = (ReceiveState)ar.AsyncState;
int bytesReceived = state.Socket.EndReceiveFrom(ar, ref state.EndPointFrom);
state.ReceiveBuffer.EndWrite(bytesReceived, (IPEndPoint)state.EndPointFrom);
byte[] data;
int offset, size;
bool isWriteBufferWait = false;
while (!state.ReceiveBuffer.BeginWrite(out data, out offset, out size))
{
if (!isWriteBufferWait)
{
isWriteBufferWait = true;
state.Logger.Error("UDP server socket is out of writable buffer space.");
}
// Wait for write queue to become available.
Thread.Sleep(6);
}
// Chain next receive.
state.Socket.BeginReceiveFrom(
data,
offset,
size,
SocketFlags.None,
ref state.EndPointFrom,
ReceiveAsyncCallback,
state);
}
/// <summary>
/// A callback the gets invoked after SSL auth completes.
/// </summary>
/// <param name="result"></param>
private void EnableServerSslCallback(IAsyncResult result)
{
canRead = true;
SslStream sslStream = (SslStream)result.AsyncState;
sslStream.EndAuthenticateAsServer(result);
SockNetLogger.Log(SockNetLogger.LogLevel.INFO, this, "Authenticated SSL with [{0}].", RemoteEndpoint);
SockNetLogger.Log(SockNetLogger.LogLevel.DEBUG, this, "[SSL] Reading data from [{0}]...", RemoteEndpoint);
this.stream = sslStream;
PooledObject <byte[]> buffer = bufferPool.Borrow();
buffer.RefCount.Increment();
receiveState = new ReceiveState()
{
buffer = buffer, offset = 0, length = buffer.Value.Length
};
currentReadResult = stream.BeginRead(buffer.Value, 0, buffer.Value.Length, new AsyncCallback(ReceiveCallback), null);
attachPromiseFulfiller.Fulfill(this);
}
/// <summary>
/// 关闭连接并释放所有相关资源。
/// </summary>
public void Close()
{
if (m_Socket == null)
{
return;
}
m_Active = false;
try
{
m_Socket.Shutdown(SocketShutdown.Both);
}
catch
{
}
finally
{
m_Socket.Close();
m_Socket = null;
m_ReceiveState = null;
if (NetworkChannelClosed != null)
{
NetworkChannelClosed(this);
}
}
}
public void ReadData()
{
if (ReadDataInner())
while (data.Count >= ExpectLength)
{
var bytes = PopBytes(ExpectLength);
switch (State)
{
case ReceiveState.Header:
{
ExpectLength = BitConverter.ToInt32(bytes, 0) - 4;
Frame = BitConverter.ToInt32(bytes, 4);
State = ReceiveState.Data;
} break;
case ReceiveState.Data:
{
Server.DispatchOrders(this, Frame, bytes);
MostRecentFrame = Frame;
ExpectLength = 8;
State = ReceiveState.Header;
Server.UpdateInFlightFrames(this);
} break;
}
}
}
public void BeginHandling()
{
Console.WriteLine("{0} connected.", skt.RemoteEndPoint);
skt.NoDelay = true;
skt.UseOnlyOverlappedIO = true;
send = new SocketAsyncEventArgs();
send.Completed += IOCompleted;
send.UserToken = new SendToken();
send.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
var receive = new SocketAsyncEventArgs();
receive.Completed += IOCompleted;
receive.UserToken = new ReceiveToken();
receive.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
receiveState = ReceiveState.ReceivingHdr;
receive.SetBuffer(0, 5);
if (!skt.ReceiveAsync(receive))
{
IOCompleted(this, receive);
}
}
public void ReadData(Server server)
{
if (ReadDataInner(server))
{
while (data.Count >= ExpectLength)
{
var bytes = PopBytes(ExpectLength);
switch (State)
{
case ReceiveState.Header:
{
ExpectLength = BitConverter.ToInt32(bytes, 0) - 4;
Frame = BitConverter.ToInt32(bytes, 4);
State = ReceiveState.Data;
} break;
case ReceiveState.Data:
{
server.DispatchOrders(this, Frame, bytes);
MostRecentFrame = Frame;
ExpectLength = 8;
State = ReceiveState.Header;
server.UpdateInFlightFrames(this);
} break;
}
}
}
}
protected void Close(Exception exception)
{
if (!this.TryClose())
{
return;
}
ReceiveState state;
lock (this.SyncRoot)
{
state = this.receiveState;
this.receiveState = null;
}
if (this.BaseSocket.Connected)
{
this.BaseSocket.Shutdown(SocketShutdown.Both);
this.BaseSocket.Dispose();
}
// Return acquired buffer to the pool
state?.Buffer.Dispose();
this.InvokeClosedEvent(exception);
}
public static void Receive(TcpSocket socket, StreamSocket client, ReceiveState receiveState, Action <byte[], int> onReceived)
{
client.InputStream.ReadAsync(receiveState.buffer.AsBuffer(0, 4), 4u, InputStreamOptions.Partial).Completed =
(IAsyncOperationWithProgress <IBuffer, uint> numBytesOp, AsyncStatus numBytesStatus) =>
{
var numBytes = BitConverter.ToInt32(numBytesOp.GetResults().ToArray(), 0);
#if HOLOLENSSOCKET_DEBUG
Debug.Log("Expecting " + numBytes.ToString() + " bytes.");
#endif
while (receiveState.buffer.Length < numBytes)
{
socket.ResizeReceiveBuffer(2);
}
client.InputStream.ReadAsync(receiveState.buffer.AsBuffer(0, numBytes), (uint)numBytes, InputStreamOptions.Partial).Completed =
(IAsyncOperationWithProgress <IBuffer, uint> bytesOp, AsyncStatus bytesStatus) =>
{
if (onReceived != null)
{
#if HOLOLENSSOCKET_DEBUG
Debug.Log("Received " + bytesOp.GetResults().Length + " bytes.");
#endif
onReceived(receiveState.buffer, receiveState.buffer.Length);
}
};
};
}
public void BeginHandling()
{
//TODO: Add account id here instead of in clientprocessor
Console.WriteLine("{0} connected.", skt.RemoteEndPoint);
//This logging code below is a HUUUUUUUUUGE godsend to anyone hosting on hamachi because anyone playing through hamachi gets a static IP that CANNOT be changed with a proxy or VPN, this makes it one million times easier to track cheating/hacking players on your server. If you're hosting on a VPS however, it's an entirely different story and may as well disable this.
var dir = @"logs"; //start of logging code
if (!System.IO.Directory.Exists(dir))
{
System.IO.Directory.CreateDirectory(dir);
}
//If someone added being able to log usernames in this log and maybe even extra computer information that would be amazing.
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(@"logs\LogOnLog.txt", true)) //HUGE problem I see, if multiple clients connect at once, one or more of the clients won't have their IP logged. Could probably result in ServerEngine crash. NOTE: Just double checked this, multiple clients connecting at once brings up NO problems, but if you're debugging with intellitrace, you will get a popup saying that multiple access's to the file "LogOnLog.txt" was established. Just ignore it and move on. This logging doesn't cause memory problems as far as I can tell.
{
writer.WriteLine("[" + DateTime.Now + "]" + skt.RemoteEndPoint + " has connected.");
} //end of logging code
skt.NoDelay = true; //don't delay sending thru sockets
skt.UseOnlyOverlappedIO = true;
send = new SocketAsyncEventArgs(); //Hmm...
send.Completed += IOCompleted;
send.UserToken = new SendToken();
send.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
var receive = new SocketAsyncEventArgs();
receive.Completed += IOCompleted;
receive.UserToken = new ReceiveToken();
receive.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
receiveState = ReceiveState.ReceivingHdr;
receive.SetBuffer(0, 5);
if (!skt.ReceiveAsync(receive)) //if the packet is received...
{
IOCompleted(this, receive); //... complete the handle
}
}
/// <summary>
/// 初始化网络频道基类的新实例。
/// </summary>
/// <param name="name">网络频道名称。</param>
/// <param name="networkChannelHelper">网络频道辅助器。</param>
public NetworkChannelBase(string name, INetworkChannelHelper networkChannelHelper)
{
m_Name = name ?? string.Empty;
m_SendPacketPool = new Queue <Packet>();
m_ReceivePacketPool = new EventPool <Packet>(EventPoolMode.Default);
m_NetworkChannelHelper = networkChannelHelper;
m_AddressFamily = AddressFamily.Unknown;
m_ResetHeartBeatElapseSecondsWhenReceivePacket = false;
m_HeartBeatInterval = DefaultHeartBeatInterval;
m_Socket = null;
m_SendState = new SendState();
m_ReceiveState = new ReceiveState();
m_HeartBeatState = new HeartBeatState();
m_SentPacketCount = 0;
m_ReceivedPacketCount = 0;
m_Active = false;
m_Disposed = false;
NetworkChannelConnected = null;
NetworkChannelClosed = null;
NetworkChannelMissHeartBeat = null;
NetworkChannelError = null;
NetworkChannelCustomError = null;
networkChannelHelper.Initialize(this);
}
private void OnReceiveAsync(IAsyncResult asyncResult)
{
var state = (ReceiveState)asyncResult.AsyncState;
//var size = state.Socket.SafeEndReceive(asyncResult);
var size = stream.EndRead(asyncResult, Error.Raise);
if (size < 1)
{
// No data was received
Dispose();
}
var frame = state.Frame;
frame.Add(state.Buffer);
if (frame.IsClosed)
{
Received.Raise(frame.ToContentString());
// Begin receiving data for a new frame
ReceiveAsync();
}
else
{
// Receive more data for the current frame
var nextState = new ReceiveState
{
//Socket = state.Socket,
Frame = state.Frame
};
ReceiveAsync(nextState);
}
}
protected override void ReceiveAsync()
{
try
{
if (client != null)
{
if (parameters.guid != Guid.Empty)
{
IPEndPoint ip = (IPEndPoint)client.Client.RemoteEndPoint;
ReceiveState state = new ReceiveState(ip);
state.Set(readBuffer);
stream.BeginRead(state.data, state.offset, state.MissingDataLength, FinalizeReceiveLength, state);
}
else
{
throw new ArgumentNullException("remote", "The connection remote and channel are not defined.");
}
}
else
{
throw new ArgumentNullException("client", "The connection tcpClient is not defined.");
}
}
catch (Exception e)
{
HandleException(e);
}
}
public void ReadData(Server server)
{
if (ReadDataInner(server))
{
while (Data.Count >= ExpectLength)
{
var bytes = PopBytes(ExpectLength);
switch (State)
{
case ReceiveState.Header:
{
ExpectLength = BitConverter.ToInt32(bytes, 0) - 4;
Frame = BitConverter.ToInt32(bytes, 4);
State = ReceiveState.Data;
if (ExpectLength < 0 || ExpectLength > MaxOrderLength)
{
server.DropClient(this);
Log.Write("server", "Dropping client {0} for excessive order length = {1}", PlayerIndex, ExpectLength);
return;
}
} break;
case ReceiveState.Data:
{
server.DispatchOrders(this, Frame, bytes);
MostRecentFrame = Frame;
ExpectLength = 8;
State = ReceiveState.Header;
} break;
}
}
}
}
private void Initialize(AddressFamily addressFamily, int maxPacketLength)
{
if (m_Socket != null)
{
Close();
m_Socket = null;
}
if (maxPacketLength <= 0)
{
throw new GameFrameworkException("Max packet length is invalid.");
}
m_MaxPacketLength = maxPacketLength;
switch (addressFamily)
{
case AddressFamily.InterNetwork:
m_NetworkType = NetworkType.IPv4;
break;
case AddressFamily.InterNetworkV6:
m_NetworkType = NetworkType.IPv6;
break;
default:
throw new GameFrameworkException(string.Format("Not supported address family '{0}'.", addressFamily.ToString()));
}
m_Socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
m_ReceiveState = new ReceiveState(maxPacketLength);
}
/// <summary>
/// 初始化网络频道。
/// </summary>
/// <param name="networkType">网络类型。</param>
/// <param name="maxPacketLength">数据包最大字节数。</param>
public void Initialize(NetworkType networkType, int maxPacketLength)
{
if (m_Socket != null)
{
Close();
}
if (maxPacketLength <= 0)
{
throw new GameFrameworkException("Max packet length is invalid.");
}
m_NetworkType = networkType;
m_MaxPacketLength = maxPacketLength;
AddressFamily addressFamily = AddressFamily.Unspecified;
switch (networkType)
{
case NetworkType.IPv4:
addressFamily = AddressFamily.InterNetwork;
break;
case NetworkType.IPv6:
addressFamily = AddressFamily.InterNetworkV6;
break;
default:
throw new GameFrameworkException("Not supported network type.");
}
m_Socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
m_ReceiveState = new ReceiveState(maxPacketLength);
}
void OnReceive(IAsyncResult asyncResult)
{
ReceiveState state = (ReceiveState)asyncResult.AsyncState;
try
{
int bytesReceived = state.ClientSocket.EndReceive(asyncResult);
if (bytesReceived == 0)
{
// Client closing the socket
state.ClientSocket.Close();
}
else
{
if (bytesReceived < state.Count)
{
state.ClientSocket.BeginReceive(state.Buffer, state.Offset + bytesReceived, state.Count - bytesReceived, SocketFlags.None, OnReceive, state);
}
else
{
if (state.ReceivingLength)
{
int length = Formatting.BytesToSize(state.Buffer, state.Offset);
Console.WriteLine("Length: {0}", length);
state.ReceivingLength = false;
state.Buffer = new byte[length];
state.Count = length;
state.ClientSocket.BeginReceive(state.Buffer, 0, length, SocketFlags.None, OnReceive, state);
}
else
{
Debugging.PrintBytes(state.Buffer, state.Count);
byte[] lengthBytes = new byte[4];
byte[] response = this.dispatcher.DispatchOperation(state.Buffer, state.Offset, state.Count);
Formatting.SizeToBytes(response.Length, lengthBytes, 0);
state.ClientSocket.Send(lengthBytes);
state.ClientSocket.Send(response);
ReceiveState receiveState = new ReceiveState
{
ClientSocket = state.ClientSocket,
Buffer = new byte[4],
Offset = 0,
Count = 4,
ReceivingLength = true,
};
state.ClientSocket.BeginReceive(receiveState.Buffer, 0, 4, SocketFlags.None, OnReceive, receiveState);
}
}
}
}
catch (ObjectDisposedException)
{
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
}
public void ReceivePackage(Socket handler, Action <Socket, PackageArgs> callback)
{
ReceiveState state = new ReceiveState(handler, callback);
Register.WriteLog("Start receiving Packages...");
handler.BeginReceive(state.Buffer, 0, SendState.FIRST_PACKAGE_SIZE, 0,
new AsyncCallback(ReceiveCallBack), state);
}
/// <summary>
/// Обработать очередной кусок принятых данных
/// </summary>
/// <param name="buffer"></param>
public void ProcessPart(byte[] buffer)
{
int i = 0;
while (i < buffer.Length)
{
if (_state == ReceiveState.RECEIVING_HEADER)
{
//Ждем заголовка
if (buffer[i] == _packageHeder[_currentHeaderByte])
{
//Читаем заголовок
_state = ReceiveState.RECEIVING_HEADER;
_currentHeaderByte++;
//Console.WriteLine("Read header");
}
else
{
//Это не заголовок
_currentHeaderByte = 0;
_state = ReceiveState.RECEIVING_HEADER;
//Console.WriteLine("Not header");
}
if (_currentHeaderByte == _packageHeder.Length)
{
//Заголовок полностью считан
_state = ReceiveState.RECEVING_BODY;
//Console.WriteLine("Header received");
}
}
else if (_state == ReceiveState.RECEVING_BODY)
{
//Читаем пакет
_receivedQueue.Add(buffer[i]);
//Console.WriteLine("Receive package");
if (_receivedQueue.Count == _packageLength)
{
//Пакет полностью считан
_state = ReceiveState.RECEIVING_HEADER;
_currentHeaderByte = 0;
//Console.WriteLine("Package received");
if (PackageReceived != null)
{
PackageReceived(this, _receivedQueue.ToArray());
}
_receivedQueue.Clear();
}
}
i++;
}
}
public SerialPacket()
{
receive_state = ReceiveState.AwaitingStartByte;
receive_next_char_is_escaped = false;
receive_address = 0;
receive_checksum = 0;
receive_length = 0;
receive_data = new List <byte>();
}
public TcpEdge GetEdge(Socket s)
{
ReceiveState rs = (ReceiveState)_sock_to_rs[s];
if (rs != null)
{
return(rs.Edge);
}
return(null);
}
public void AddEdge(TcpEdge e)
{
Socket s = e.Socket;
AllSockets.Add(s);
ReceiveState rs = new ReceiveState(e, BA);
_sock_to_rs[s] = rs;
Interlocked.Increment(ref TEL._count);
}
private void BeginReceive(ReceiveState state)
{
this.BaseSocket.BeginReceive(
state.Buffer.Buffer,
state.Buffer.Offset + state.ReceivedBytes,
state.Buffer.Length - state.ReceivedBytes,
SocketFlags.None,
this.BeginReceiveCallback,
state);
}
/// <summary>
/// Receive data asynchronous
/// </summary>
public void ReceiveAsync()
{
var state = new ReceiveState
{
//Socket = socket,
Frame = new Frame()
};
ReceiveAsync(state);
}
private void ReceiveAsync(ReceiveState state)
{
//var socket = state.Socket;
if (socket == null || !socket.Connected)
{
Disconnected.Raise(this);
return;
}
stream.BeginRead(state.Buffer, 0, state.Buffer.Length, OnReceiveAsync, state);
}
void receiveLength(ReceiveState state)
{
int offset = state == null ? 0 : 1;
state = state == null ? new ReceiveState() : state;
_stream.BeginRead(state.len,
offset,
2 - offset,
_receiveCallback,
state);
}
public SerialPacket()
{
receive_state = ReceiveState.AwaitingStartByte;
receive_next_char_is_escaped = false;
receive_address = 0;
receive_checksum = 0;
receive_length = 0;
receive_data = new List<byte>();
}
/// <summary>
/// Feed a byte to the serial depacketizing state machine
/// </summary>
/// <param name="data"></param>
/// <returns>non-null byte [] when a packet is received completely</returns>
public byte[] ProcessByte(byte data)
{
// Check for invalid data conditions, ignore any bad bytes
if (data == null_BYTE || data == MAX_BYTE)
{
Console.WriteLine("Serial Error: Got bad byte from serial stream");
return null;
}
if (receive_state == ReceiveState.AwaitingStartByte && data != START_BYTE)
{
Console.WriteLine("Serial Error: Got an unexpected byte while waiting for start byte");
return null;
}
if (receive_state != ReceiveState.AwaitingStartByte && data == START_BYTE)
{
Console.WriteLine("Serial Error: start byte found while already processing a packet");
return null;
}
// Check if the next byte is escaped
if (data == ESCAPE_CHAR)
{
receive_next_char_is_escaped = true;
return null;
}
if (receive_next_char_is_escaped)
{
if (data == ESCAPE_CHAR_ESCAPED) {
data = ESCAPE_CHAR;
} else if (data == START_BYTE_ESCAPED) {
data = START_BYTE;
} else if (data == null_BYTE_ESCAPED) {
data = null_BYTE;
} else if (data == MAX_BYTE_ESCAPED) {
data = MAX_BYTE;
}
receive_next_char_is_escaped = false;
}
switch (receive_state)
{
case ReceiveState.AwaitingStartByte:
receive_next_char_is_escaped = false;
receive_state = ReceiveState.AwaitingAddress;
break;
case ReceiveState.AwaitingAddress:
receive_address = data;
receive_checksum = data;
receive_state = ReceiveState.AwaitingLength;
break;
case ReceiveState.AwaitingLength:
receive_length = data;
receive_checksum += data;
receive_data.Clear();
receive_state = ReceiveState.AwaitingData;
break;
case ReceiveState.AwaitingData:
receive_checksum += data;
receive_data.Add(data);
if (--receive_length == 0)
{
receive_state = ReceiveState.AwaitingChecksum;
}
break;
case ReceiveState.AwaitingChecksum:
receive_state = ReceiveState.AwaitingStartByte;
receive_checksum = (byte)~receive_checksum;
if (data != receive_checksum)
{
Console.WriteLine("Serial Error: Checksum Mismatch");
return null;
}
return receive_data.ToArray();
}
return null;
}
void PrepareToReceiveImageHeader(SocketAsyncEventArgs args)
{
args.SetBuffer(headerBuffer, 0, headerBuffer.Length);
numHeaderBytesReceived = 0;
receiveState = ReceiveState.WaitingForImageHeader;
ReceiveNextPacketAsync(args);
}
void ProcessImageHeader(SocketAsyncEventArgs args)
{
// Have we received an entire image header yet?
numHeaderBytesReceived += args.BytesTransferred;
if (numHeaderBytesReceived < ImageHeaderSize)
{
// No, so wait till we get some more data.
args.SetBuffer(numHeaderBytesReceived, ImageHeaderSize - numHeaderBytesReceived);
ReceiveNextPacketAsync(args);
return;
}
// Marshal it into a struct.
GCHandle pinnedBuffer = GCHandle.Alloc(args.Buffer, GCHandleType.Pinned);
imageHeader = (ImageHeader)Marshal.PtrToStructure(pinnedBuffer.AddrOfPinnedObject(), typeof(ImageHeader));
pinnedBuffer.Free();
// Check it looks sensible.
if (imageHeader.MagicNumber != ImageHeaderMagicNumber ||
imageHeader.Height <= 0 && imageHeader.Height > 10000 ||
imageHeader.Width <= 0 || imageHeader.Width > 10000 ||
imageHeader.Size <= 0 || imageHeader.Size > 10000000)
{
Debug.WriteLine("ERROR: bad image header");
ReceiveNextPacketAsync(args);
return;
}
// Looks like we've got a new image to download. Setup to receive the image data.
numImagesAttemptedToReceive++;
imageBuffer = new byte[imageHeader.Size];
numImagesBytesReceived = 0;
receiveState = ReceiveState.WaitingForDataBlock;
args.SetBuffer(imageBuffer, 0, imageBuffer.Length);
ReceiveNextPacketAsync(args);
}
internal MessageReassembler( Controller parent )
{
m_parent = parent;
m_state = ReceiveState.Initialize;
}
void receive(ReceiveState state)
{
_stream.BeginRead(state.data,
state.offset,
state.length - state.offset,
_receiveCallback,
state);
}
public StreamEngine(AsyncSocket handle, Options options, string endpoint)
{
m_handle = handle;
m_insize = 0;
m_ioEnabled = false;
m_sendingState = SendState.Idle;
m_receivingState = ReceiveState.Idle;
m_outsize = 0;
m_session = null;
m_options = options;
m_plugged = false;
m_endpoint = endpoint;
m_socket = null;
m_encoder = null;
m_decoder = null;
m_actionsQueue = new Queue<StateMachineAction>();
// Set the socket buffer limits for the underlying socket.
if (m_options.SendBuffer != 0)
{
m_handle.SendBufferSize = m_options.SendBuffer;
}
if (m_options.ReceiveBuffer != 0)
{
m_handle.ReceiveBufferSize = m_options.ReceiveBuffer;
}
}
private void ProcessInput()
{
bool disconnection = false;
int processed;
if (m_insize == -1)
{
m_insize = 0;
disconnection = true;
}
if (m_options.RawSocket)
{
if (m_insize == 0 || !m_decoder.MessageReadySize(m_insize))
{
processed = 0;
}
else
{
processed = m_decoder.ProcessBuffer(m_inpos, m_insize);
}
}
else
{
// Push the data to the decoder.
processed = m_decoder.ProcessBuffer(m_inpos, m_insize);
}
if (processed == -1)
{
disconnection = true;
}
else
{
// Stop polling for input if we got stuck.
if (processed < m_insize)
{
m_receivingState = ReceiveState.Stuck;
m_inpos.AdvanceOffset(processed);
m_insize -= processed;
}
else
{
m_inpos = null;
m_insize = 0;
}
}
// Flush all messages the decoder may have produced.
m_session.Flush();
// An input error has occurred. If the last decoded message
// has already been accepted, we terminate the engine immediately.
// Otherwise, we stop waiting for socket events and postpone
// the termination until after the message is accepted.
if (disconnection)
{
if (m_decoder.Stalled())
{
m_ioObject.RemoveSocket(m_handle);
m_ioEnabled = false;
m_state = State.Stalled;
}
else
{
Error();
}
}
else if (m_receivingState != ReceiveState.Stuck)
{
m_decoder.GetBuffer(out m_inpos, out m_insize);
BeginRead(m_inpos, m_insize);
}
}
private void Activate()
{
// Handshaking was successful.
// Switch into the normal message flow.
m_state = State.Active;
m_outsize = 0;
m_sendingState = SendState.Active;
BeginSending();
m_receivingState = ReceiveState.Active;
if (m_insize == 0)
{
m_decoder.GetBuffer(out m_inpos, out m_insize);
BeginRead(m_inpos, m_insize);
}
else
{
ProcessInput();
}
}
private void Handle(Action action, SocketError socketError, int bytesTransferred)
{
switch (m_state)
{
case State.Closed:
switch (action)
{
case Action.Start:
if (m_options.RawSocket)
{
m_encoder = new RawEncoder(Config.OutBatchSize, m_session, m_options.Endian);
m_decoder = new RawDecoder(Config.InBatchSize, m_options.MaxMessageSize, m_session, m_options.Endian);
Activate();
}
else
{
m_state = State.Handshaking;
m_handshakeState = HandshakeState.Closed;
HandleHandshake(action, socketError, bytesTransferred);
}
break;
}
break;
case State.Handshaking:
HandleHandshake(action, socketError, bytesTransferred);
break;
case State.Active:
switch (action)
{
case Action.InCompleted:
m_insize = EndRead(socketError, bytesTransferred);
ProcessInput();
break;
case Action.ActivateIn:
// if we stuck let's continue, other than that nothing to do
if (m_receivingState == ReceiveState.Stuck)
{
m_receivingState = ReceiveState.Active;
ProcessInput();
}
break;
case Action.OutCompleted:
int bytesSent = EndWrite(socketError, bytesTransferred);
// IO error has occurred. We stop waiting for output events.
// The engine is not terminated until we detect input error;
// this is necessary to prevent losing incoming messages.
if (bytesSent == -1)
{
m_sendingState = SendState.Error;
}
else
{
m_outpos.AdvanceOffset(bytesSent);
m_outsize -= bytesSent;
BeginSending();
}
break;
case Action.ActivateOut:
// if we idle we start sending, other than do nothing
if (m_sendingState == SendState.Idle)
{
m_sendingState = SendState.Active;
BeginSending();
}
break;
default:
Debug.Assert(false);
break;
}
break;
case State.Stalled:
switch (action)
{
case Action.ActivateIn:
// There was an input error but the engine could not
// be terminated (due to the stalled decoder).
// Flush the pending message and terminate the engine now.
m_decoder.ProcessBuffer(m_inpos, 0);
Debug.Assert(!m_decoder.Stalled());
m_session.Flush();
Error();
break;
case Action.ActivateOut:
break;
}
break;
}
}
/// <summary>
/// Essential Rx method. Drives state machine by reading data and processing it. This works in
/// conjunction with NotificationThreadWorker [Tx].
/// </summary>
internal void Process()
{
int count;
int bytesRead;
try
{
switch(m_state)
{
case ReceiveState.Initialize:
m_rawPos = 0;
m_base = new MessageBase();
m_base.m_header = new Packet();
m_raw = new MessageRaw ();
m_raw .m_header = m_parent.CreateConverter().Serialize( m_base.m_header );
m_state = ReceiveState.WaitingForHeader;
goto case ReceiveState.WaitingForHeader;
case ReceiveState.WaitingForHeader:
count = m_raw.m_header.Length - m_rawPos;
bytesRead = m_parent.Read(m_raw.m_header, m_rawPos, count);
m_rawPos += bytesRead;
while(m_rawPos > 0)
{
int flag_Debugger = ValidSignature( m_parent.marker_Debugger );
int flag_Packet = ValidSignature( m_parent.marker_Packet );
if(flag_Debugger == 1 || flag_Packet == 1)
{
m_state = ReceiveState.ReadingHeader;
goto case ReceiveState.ReadingHeader;
}
if(flag_Debugger == 0 || flag_Packet == 0)
{
break; // Partial match.
}
m_parent.App.SpuriousCharacters( m_raw.m_header, 0, 1 );
Array.Copy( m_raw.m_header, 1, m_raw.m_header, 0, --m_rawPos );
}
break;
case ReceiveState.ReadingHeader:
count = m_raw.m_header.Length - m_rawPos;
bytesRead = m_parent.Read(m_raw.m_header, m_rawPos, count);
m_rawPos += bytesRead;
if (bytesRead != count) break;
m_state = ReceiveState.CompleteHeader;
goto case ReceiveState.CompleteHeader;
case ReceiveState.CompleteHeader:
try
{
m_parent.CreateConverter().Deserialize( m_base.m_header, m_raw.m_header );
if(VerifyHeader() == true)
{
bool fReply = (m_base.m_header.m_flags & Flags.c_Reply) != 0;
m_base.DumpHeader( "Receiving" );
if(m_base.m_header.m_size != 0)
{
m_raw.m_payload = new byte[m_base.m_header.m_size];
//reuse m_rawPos for position in header to read.
m_rawPos = 0;
m_state = ReceiveState.ReadingPayload;
goto case ReceiveState.ReadingPayload;
}
else
{
m_state = ReceiveState.CompletePayload;
goto case ReceiveState.CompletePayload;
}
}
}
catch(ThreadAbortException)
{
throw;
}
catch(Exception e)
{
Console.WriteLine( "Fault at payload deserialization:\n\n{0}", e.ToString() );
}
m_state = ReceiveState.Initialize;
if((m_base.m_header.m_flags & Flags.c_NonCritical) == 0)
{
IncomingMessage.ReplyBadPacket( m_parent, Flags.c_BadHeader );
}
break;
case ReceiveState.ReadingPayload:
count = m_raw.m_payload.Length - m_rawPos;
bytesRead = m_parent.Read(m_raw.m_payload, m_rawPos, count);
m_rawPos += bytesRead;
if (bytesRead != count) break;
m_state = ReceiveState.CompletePayload;
goto case ReceiveState.CompletePayload;
case ReceiveState.CompletePayload:
if(VerifyPayload() == true)
{
try
{
bool fReply = (m_base.m_header.m_flags & Flags.c_Reply) != 0;
if((m_base.m_header.m_flags & Flags.c_NACK) != 0)
{
m_raw.m_payload = null;
}
m_parent.App.ProcessMessage( this.GetCompleteMessage(), fReply );
m_state = ReceiveState.Initialize;
return;
}
catch(ThreadAbortException)
{
throw;
}
catch(Exception e)
{
Console.WriteLine( "Fault at payload deserialization:\n\n{0}", e.ToString() );
}
}
m_state = ReceiveState.Initialize;
if((m_base.m_header.m_flags & Flags.c_NonCritical) == 0)
{
IncomingMessage.ReplyBadPacket( m_parent, Flags.c_BadPayload );
}
break;
}
}
catch
{
m_state = ReceiveState.Initialize;
throw;
}
}
public void byteReceived(byte newByte)
{
switch(curState)
{
case ReceiveState.FIND_FIRST_HEADER_CHAR:
if(newByte == '#')
{
curState = ReceiveState.FIND_SECOND_HEADER_CHAR;
}
else if(newByte == 'P')
{
psocReadyAckStringIterator.next();
curState = ReceiveState.RECEIVING_PSOC_READY_ACK;
}
else
{
throw new ArgumentException("invalid state");
}
break;
case ReceiveState.RECEIVING_PSOC_READY_ACK:
if(newByte == psocReadyAckStringIterator.next())
{
if(psocReadyAckStringIterator.finished())
{
psocReadyAckStringIterator.reset();
curState = ReceiveState.FIND_FIRST_HEADER_CHAR;
if(PsocReadyEvent != null) PsocReadyEvent(this, new PsocReadyEventArgs());
}
}
else
{
throw new Exception("invalid state");
}
break;
case ReceiveState.FIND_SECOND_HEADER_CHAR:
if(newByte == 'F')
{
curState = ReceiveState.READING_NUM_SAMPLES;
numExpectedSamples = 0;
}
else
{
throw new ArgumentException("invalid state");
}
break;
case ReceiveState.READING_NUM_SAMPLES:
if(newByte == 'D')
{
if(numExpectedSamples == 0)
{
throw new ArgumentException("can't have a frame size of zero");
}
numBytesReceived = 0;
numExpectedBytes = numExpectedSamples * 2;
sampleFrameAssembler.SetNumSamplesExpected(numExpectedSamples);
curState = ReceiveState.RECEIVING_SAMPLES;
}
else if(newByte >= '0' && newByte <= '9')
{
numExpectedSamples *= 10;
numExpectedSamples += (uint)(newByte - '0');
}
else
{
throw new ArgumentException("invalid state");
}
break;
case ReceiveState.RECEIVING_SAMPLES:
sampleAssembler.AddReceivedByte(newByte);
if(++numBytesReceived == numExpectedBytes)
{
curState = ReceiveState.FIND_FIRST_HEADER_CHAR;
}
break;
}
}
