/// <summary>
/// Adiciona o terminador do cabeçalho.
/// </summary>
/// <param name="header"></param>
/// <param name="terminator"></param>
public void AddHeaderTerminator(byte[] header, byte[] terminator)
{
lock (_formatLock)
{
foreach (HeaderTerminator terminator2 in this._headerTerminatorList)
{
if (Matches(header, 0, header.Length, terminator2.Header, GetHeaderLength(header), false))
{
foreach (byte[] buffer in terminator2.Terminators)
{
if (Matches(terminator, 0, terminator.Length, buffer, GetTerminatorLength(buffer), false))
{
return;
}
}
terminator2.Terminators.Add(terminator);
}
}
HeaderTerminator item = new HeaderTerminator {
Header = header
};
item.Terminators.Add(terminator);
_headerTerminatorList.Add(item);
}
}
/// <summary>
/// Limpa os buffers.
/// </summary>
public void CleanBuffers()
{
_bufferList.Clear();
_bufferIndex = 0;
_bufferReadIndex = 0;
_leftOverSize = 0;
_headerTerminator = null;
}
/// <summary>
/// Lê o buffer.
/// </summary>
/// <param name="data"></param>
/// <param name="expectedSize">Tamanho esperado.</param>
/// <returns></returns>
public bool ReadBuffer(out byte[] data, int expectedSize)
{
_headerTerminator = null;
int maxDataLength = expectedSize;
if (MaxDataLength < maxDataLength)
{
maxDataLength = MaxDataLength;
}
data = null;
try
{
while (0 < _bufferList.Count)
{
byte[] buffer = _bufferList[0];
if (buffer != null)
{
while (_bufferIndex < buffer.Length)
{
if (maxDataLength <= _bufferReadIndex)
{
break;
}
if (_bufferRead.Length <= _bufferReadIndex)
{
Array.Resize <byte>(ref _bufferRead, _bufferRead.Length * 2);
}
_bufferRead[_bufferReadIndex] = buffer[_bufferIndex];
_bufferReadIndex++;
_bufferIndex++;
}
if (maxDataLength <= _bufferReadIndex)
{
Array.Resize <byte>(ref _bufferRead, _bufferReadIndex);
data = _bufferRead;
_bufferRead = new byte[1024];
_bufferReadIndex = 0;
_leftOverSize = expectedSize - data.Length;
return(true);
}
}
_bufferList.RemoveAt(0);
_bufferIndex = 0;
}
}
catch (ArgumentOutOfRangeException)
{
return(false);
}
return(false);
}
/// <summary>
/// Recupera o terminador com base nos dados informados.
/// </summary>
/// <param name="data"></param>
/// <param name="length"></param>
/// <returns></returns>
private HeaderTerminator GetHeaderTerminator(byte[] data, int length)
{
HeaderTerminator terminator = null;
lock (_formatLock)
{
foreach (HeaderTerminator terminator2 in this._headerTerminatorList)
{
byte[] header = terminator2.Header;
if ((IsNone(header) || Matches(header, 0, header.Length, data, length, false)) && ((terminator == null) || (GetHeaderLength(terminator.Header) < GetHeaderLength(header))))
{
terminator = terminator2;
}
}
}
return(terminator);
}
/// <summary>
/// Lê o buffer.
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public bool ReadBuffer(out byte[] data)
{
data = null;
try
{
int startIndex = 0;
while (0 < _bufferList.Count)
{
byte[] buffer = _bufferList[0];
if (buffer != null)
{
while (_bufferIndex < buffer.Length)
{
if (this._bufferRead.Length <= _bufferReadIndex)
{
Array.Resize <byte>(ref _bufferRead, _bufferRead.Length * 2);
}
_bufferRead[_bufferReadIndex] = buffer[_bufferIndex];
_bufferReadIndex++;
_bufferIndex++;
if ((_headerTerminator == null) && (_bufferReadIndex <= 5))
{
_headerTerminator = GetHeaderTerminator(_bufferRead, _bufferReadIndex);
if (_headerTerminator != null)
{
startIndex = GetHeaderLength(_headerTerminator.Header);
}
}
bool flag = EndsWithTerminator(_bufferRead, startIndex, _bufferReadIndex, _headerTerminator);
if (flag)
{
_headerTerminator = null;
}
if ((flag || (MaxDataLength <= _bufferReadIndex)) || UseFormatLength)
{
int num2;
if (0 < _leftOverSize)
{
return(ReadBuffer(out data, _leftOverSize));
}
if (UseFormatLength && ReadDataLength(out num2))
{
return(ReadBuffer(out data, num2));
}
if (!UseFormatLength && (flag || (MaxDataLength <= _bufferReadIndex)))
{
Array.Resize <byte>(ref _bufferRead, _bufferReadIndex);
data = this._bufferRead;
_bufferRead = new byte[1024];
_bufferReadIndex = 0;
return(true);
}
}
}
}
_bufferList.RemoveAt(0);
_bufferIndex = 0;
}
}
catch (ArgumentOutOfRangeException)
{
return(false);
}
return(false);
}
/// <summary>
/// Verifica se os dados informados terminam com o terminador informado.
/// </summary>
/// <param name="data">Buffer.</param>
/// <param name="startIndex">Indice de inicio para leitura do buffer.</param>
/// <param name="length">Tamanho dos dados que devem ser lidos.</param>
/// <param name="headerTerminator"></param>
/// <returns></returns>
private static bool EndsWithTerminator(byte[] data, int startIndex, int length, HeaderTerminator headerTerminator)
{
if (headerTerminator != null)
{
foreach (byte[] buffer in headerTerminator.Terminators)
{
if (IsNone(buffer))
{
return(false);
}
if (length < (startIndex + GetTerminatorLength(buffer)))
{
return(false);
}
if (Matches(buffer, 0, GetTerminatorLength(buffer), data, length, true))
{
return(true);
}
}
}
return(false);
}
