private void PushResetData(ArraySegment <byte> raw, int rest, IBufferState state)
{
var segment = new ArraySegment <byte>(raw.Array, raw.Offset + raw.Count - rest, rest);
state.IncreaseReference();
m_ReceiveCache.Add(segment, state);
}
public void DeleteOperate(IBufferState bufferState)
{
IBuffer buffer;
(_, _, _, _, buffer) = bufferState.Info();
if (buffer is Buffer temp)
{
temp.Delete();
}
}
public void SetEndOfBuffer(IBufferState bufferState)
{
int position;
IBuffer buffer;
Buffer temp;
(_, _, _, position, buffer) = bufferState.Info();
temp = Find(buffer, position);
temp.next = temp;
}
public bool IsEndOfBuffer(IBufferState bufferState)
{
int position;
IBuffer buffer;
Buffer temp;
(_, _, _, position, buffer) = bufferState.Info();
temp = Find(buffer, position);
return(temp.next == temp && temp.GetWriteAbsolutePosition() <= position);
}
public bool IsFull(IBufferState bufferState)
{
IBuffer buffer;
int position;
(_, _, _, position, buffer) = bufferState.Info();
Buffer temp = Find(buffer, position);
return(bufferLength == temp.wroteLength);
}
public void SeekOfWrite(IBufferState bufferState)
{
int position;
IBuffer buffer;
Buffer temp;
(_, _, _, position, buffer) = bufferState.Info();
temp = Find(buffer, position);
(temp, position) = temp.MoveWriteAbsolutePosition();
_ = bufferState.Info(true, null, null, position, temp);
}
public void Write(byte[] b, IBufferState bufferState)
{
int position, start, length, bufferStart;
IBuffer buffer;
Buffer temp;
(_, start, length, position, buffer) = bufferState.Info();
bufferStart = position % bufferLength;
temp = Find(buffer, position);
int actual = temp.WriteByte(b, start, length, bufferStart);
bufferState.Info(actual == length, start + actual, length - actual, position + actual, temp);
}
public int Read(IntPtr ptr, IBufferState bufferState)
{
int position, start, length, bufferStart;
IBuffer buffer;
Buffer temp;
(_, start, length, position, buffer) = bufferState.Info();
bufferStart = position % bufferLength;
temp = Find(buffer, position);
int actual = temp.ReadPtr(ptr, start, length, bufferStart);
_ = bufferState.Info(actual == length, start + actual, length - actual, position + actual, temp);
return(actual);
}
internal ProcessResult ProcessReceivedData(ArraySegment <byte> data, IBufferState state)
{
LocalDataStoreSlot slot = null;
try
{
slot = Thread.GetNamedDataSlot(m_SesionDataSlotName);
Thread.SetData(slot, this.AppSession);
var result = DataProcessor.Process(data, state);
if (result.State == ProcessState.Error)
{
if (string.IsNullOrEmpty(result.Message))
{
AppSession.Logger.Error("Protocol error");
}
else
{
AppSession.Logger.ErrorFormat("Protocol error: {0}", result.Message);
}
this.Close(CloseReason.ProtocolError);
}
return(result);
}
catch (Exception ex)
{
LogError("Protocol error", ex);
this.Close(CloseReason.ProtocolError);
return(ProcessResult.Create(ProcessState.Error));
}
finally
{
if (slot != null)
{
Thread.SetData(slot, null);
}
}
}
/// <summary>
/// Processes the input segment.
/// </summary>
/// <param name="segment">The input segment.</param>
/// <param name="state">The buffer state.</param>
/// <returns>
/// the processing result
/// </returns>
public virtual ProcessResult Process(ArraySegment <byte> segment, IBufferState state)
{
m_ReceiveCache.Add(segment, state);
var rest = 0;
while (true)
{
var packageInfo = m_ReceiveFilter.Filter(m_ReceiveCache, out rest);
if (m_ReceiveFilter.State == FilterState.Error)
{
m_BufferRecycler.Return(m_ReceiveCache.GetAllCachedItems(), 0, m_ReceiveCache.Count);
return(ProcessResult.Create(ProcessState.Error));
}
if (m_MaxPackageLength > 0)
{
var length = m_ReceiveCache.Total;
if (length > m_MaxPackageLength)
{
m_BufferRecycler.Return(m_ReceiveCache.GetAllCachedItems(), 0, m_ReceiveCache.Count);
return(ProcessResult.Create(ProcessState.Error, string.Format("Max package length: {0}, current processed length: {1}", m_MaxPackageLength, length)));
}
}
//Receive continue
if (packageInfo == null)
{
if (rest > 0)
{
PushResetData(segment, rest, state);
continue;
}
return(ProcessResult.Create(ProcessState.Cached));
}
m_ReceiveFilter.Reset();
var nextReceiveFilter = m_ReceiveFilter.NextReceiveFilter;
if (nextReceiveFilter != null)
{
m_ReceiveFilter = nextReceiveFilter;
}
m_PackageHandler.Handle(packageInfo);
if (packageInfo is IBufferedPackageInfo && // is a buffered package
(packageInfo as IBufferedPackageInfo).Data is BufferList) // and it uses receive buffer directly
{
// so we need to create a new receive buffer container to use
m_ReceiveCache = new BufferList();
if (rest <= 0)
{
return(ProcessResult.Create(ProcessState.Cached));
}
}
else
{
ReturnOtherThanLastBuffer();
if (rest <= 0)
{
return(ProcessResult.Create(ProcessState.Completed));
}
}
PushResetData(segment, rest, state);
}
}
internal ProcessResult ProcessReceivedData(ArraySegment<byte> data, IBufferState state)
{
LocalDataStoreSlot slot = null;
try
{
slot = Thread.GetNamedDataSlot(m_SesionDataSlotName);
Thread.SetData(slot, this.AppSession);
var result = DataProcessor.Process(data, state);
if (result.State == ProcessState.Error)
{
if (string.IsNullOrEmpty(result.Message))
AppSession.Logger.Error("Protocol error");
else
AppSession.Logger.ErrorFormat("Protocol error: {0}", result.Message);
this.Close(CloseReason.ProtocolError);
}
return result;
}
catch (Exception ex)
{
LogError("Protocol error", ex);
this.Close(CloseReason.ProtocolError);
return ProcessResult.Create(ProcessState.Error);
}
finally
{
if (slot != null)
Thread.SetData(slot, null);
}
}
/// <summary>
/// Adds the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="state">The state.</param>
public void Add(ArraySegment <byte> item, IBufferState state)
{
state.IncreaseReference();
m_List.Add(new KeyValuePair <ArraySegment <byte>, IBufferState>(item, state));
m_Total += item.Count;
}
public virtual ProcessResult Process(ArraySegment <byte> segment, IBufferState state)
{
m_ReceiveCache.Add(segment, state);
var rest = 0;
while (true)
{
var packageInfo = m_ReceiveFilter.Filter(m_ReceiveCache, out rest);
if (m_ReceiveFilter.State == FilterState.Error)
{
m_BufferRecycler.Return(m_ReceiveCache.GetAllCachedItems(), 0, m_ReceiveCache.Count);
return(ProcessResult.Create(ProcessState.Error));
}
if (m_MaxPackageLength > 0)
{
var length = m_ReceiveCache.Total;
if (length > m_MaxPackageLength)
{
m_BufferRecycler.Return(m_ReceiveCache.GetAllCachedItems(), 0, m_ReceiveCache.Count);
return(ProcessResult.Create(ProcessState.Error, string.Format("Max package length: {0}, current processed length: {1}", m_MaxPackageLength, length)));
}
}
//Receive continue
if (packageInfo == null)
{
if (rest > 0)
{
PushResetData(segment, rest, state);
continue;
}
//Because the current buffer is cached, so new buffer is required for receiving
FireNewReceiveBufferRequired();
return(ProcessResult.Create(ProcessState.Cached));
}
m_ReceiveFilter.Reset();
var nextReceiveFilter = m_ReceiveFilter.NextReceiveFilter;
if (nextReceiveFilter != null)
{
m_ReceiveFilter = nextReceiveFilter;
}
m_PackageHandler.Handle(packageInfo);
if (packageInfo is IRawPackageInfo)
{
m_ReceiveCache = new ReceiveCache();
if (rest <= 0)
{
return(ProcessResult.Create(ProcessState.Cached));
}
}
else
{
ReturnOtherThanLastBuffer();
if (rest <= 0)
{
return(ProcessResult.Create(ProcessState.Completed));
}
}
PushResetData(segment, rest, state);
}
}
