/// <summary>
/// Is called when asynchrounous line reading has completed.
/// </summary>
/// <param name="e">Callback data.</param>
private void OnReadHeader_ReadLine_Completed(ReadLine_EventArgs e)
{
try
{
m_TotalReadedCount += e.ReadedCount;
// We got error.
if (e.Exception != null)
{
try
{
m_pBufferedStream.Flush();
m_pStoreStream.Flush();
}
catch
{
// Just skip excpetions here, otherwise we may hide original exception,
// if exceptions is thrown by flush.
}
// Maximum line size exceeded, but junk data wanted.
if (m_ExceededAction == SizeExceededAction.JunkAndThrowException &&
e.Exception is LineSizeExceededException)
{
m_IsLineSizeExceeded = true;
// Start reading next data buffer block.
m_pStreamHelper.BeginReadLineInternal(m_pLineBuffer,
m_ExceededAction,
null,
OnReadHeader_ReadLine_Completed,
false,
false);
}
// Unknown exception or ThrowException, so we are done.
else
{
ReadHeaderCompleted(e.Exception);
}
}
// We got terminator, so we are done now.
else if (e.Count == 0 || e.ReadedCount == 0)
{
m_pBufferedStream.Flush();
m_pStoreStream.Flush();
// LineSizeExceeded.
if (m_IsLineSizeExceeded)
{
ReadHeaderCompleted(new LineSizeExceededException());
}
// DataSizeExceeded.
else if (m_TotalReadedCount > m_MaxSize)
{
ReadHeaderCompleted(new DataSizeExceededException());
}
// Completed successfuly.
else
{
ReadHeaderCompleted(null);
}
}
// Just append line to store stream and get next line.
else
{
// Maximum allowed data size exceeded.
if (m_TotalReadedCount > m_MaxSize)
{
if (m_ExceededAction == SizeExceededAction.ThrowException)
{
ReadHeaderCompleted(new DataSizeExceededException());
return;
}
// Junk data.
//else{
//}
}
else
{
m_pBufferedStream.Write(e.LineBuffer, 0, e.Count);
m_pBufferedStream.Write(m_pStreamHelper.m_LineBreak,
0,
m_pStreamHelper.m_LineBreak.Length);
}
// Start reading new line.
m_pStreamHelper.BeginReadLineInternal(m_pLineBuffer,
m_ExceededAction,
null,
OnReadHeader_ReadLine_Completed,
false,
false);
}
}
catch (Exception x)
{
ReadHeaderCompleted(x);
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <param name="maxLineSize">Specifies maximum line size in bytes.</param>
/// <param name="bufferRead">Specifies if source stream reads are buffered..</param>
public StreamHelper(Stream stream, int maxLineSize, bool bufferRead)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (maxLineSize < 1 || maxLineSize > Workaround.Definitions.MaxStreamLineLength)
{
throw new ArgumentException("Parameter maxLineSize value must be >= 1 and <= Workaround.Definitions.MaxStreamLineLength !");
}
m_IsReadBuffered = bufferRead;
if (m_IsReadBuffered)
{
m_pReadBuffer = new byte[Workaround.Definitions.MaxStreamLineLength];
}
m_pStream = stream;
m_pLineBuffer = new byte[maxLineSize];
m_MaxLineSize = maxLineSize;
m_pRLine_EventArgs = new ReadLine_EventArgs();
m_pRLine_ByteBuffer = new byte[1];
}
/// <summary>
/// Is called when BeginWritePeriodTerminated stream.BeginReadLine has completed.
/// </summary>
/// <param name="e">Callback data.</param>
private void InternalBeginWritePeriodTerminatedReadLineCompleted(ReadLine_EventArgs e)
{
try
{
// Error happened during read.
if (e.Exception != null)
{
InternalBeginWritePeriodTerminatedCompleted(e.Exception);
}
// We reached end of stream, no more data.
else if (e.ReadedCount == 0)
{
InternalBeginWritePeriodTerminatedCompleted(null);
}
else
{
m_BeginWritePeriodTerminated_Readed += e.ReadedCount;
// Maximum allowed data size exceeded.
if (m_BeginWritePeriodTerminated_Readed > m_BeginWritePeriodTerminated_MaxSize)
{
throw new DataSizeExceededException();
}
// If line starts with period, addtional period is added.
if (e.LineBuffer[0] == '.')
{
m_pBeginWritePeriodTerminated_BufferedStream.WriteByte((int) '.');
m_BeginWritePeriodTerminated_Written++;
}
// Write readed line to buffered stream.
m_pBeginWritePeriodTerminated_BufferedStream.Write(e.LineBuffer, 0, e.Count);
m_pBeginWritePeriodTerminated_BufferedStream.Write(m_LineBreak, 0, m_LineBreak.Length);
m_BeginWritePeriodTerminated_Written += e.Count + m_LineBreak.Length;
}
}
catch (Exception x)
{
InternalBeginWritePeriodTerminatedCompleted(x);
}
}