/// <summary>
/// Reads and logs specified line from connected host.
/// </summary>
/// <returns>Returns readed line.</returns>
protected string ReadLine()
{
SmartStream.ReadLineAsyncOP args = new SmartStream.ReadLineAsyncOP(new byte[32000],SizeExceededAction.JunkAndThrowException);
this.TcpStream.ReadLine(args,false);
if(args.Error != null){
throw args.Error;
}
string line = args.LineUtf8;
if(args.BytesInBuffer > 0)
{
OnPacketReceived(line);
// LogAddRead(args.BytesInBuffer,line);
}
else{
//LogAddText("Remote host closed connection.");
OnDisonnected();
}
return line;
}
/// <summary>
/// Starts reading incoming command from the connected client.
/// </summary>
private void BeginReadCmd()
{
if (this.IsDisposed)
{
return;
}
try
{
SmartStream.ReadLineAsyncOP readLineOP = new SmartStream.ReadLineAsyncOP(new byte[32000], SizeExceededAction.JunkAndThrowException);
// This event is raised only if read period-terminated opeartion completes asynchronously.
readLineOP.Completed += new EventHandler<EventArgs<SmartStream.ReadLineAsyncOP>>(delegate(object sender, EventArgs<SmartStream.ReadLineAsyncOP> e)
{
if (ProcessCmd(readLineOP))
{
BeginReadCmd();
}
});
// Process incoming commands while, command reading completes synchronously.
while (this.TcpStream.ReadLine(readLineOP, true))
{
if (!ProcessCmd(readLineOP))
{
break;
}
}
}
catch (Exception x)
{
OnError(x);
}
}
/// <summary>
/// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
/// </summary>
/// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
/// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
/// <param name="count">The maximum number of bytes to be read from the current stream.</param>
/// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>buffer</b> is null reference.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
/// <exception cref="NotSupportedException">Is raised when reading not supported.</exception>
public override int Read(byte[] buffer,int offset,int count)
{
if(buffer == null){
throw new ArgumentNullException("buffer");
}
if(offset < 0 || offset > buffer.Length){
throw new ArgumentException("Invalid argument 'offset' value.");
}
if(offset + count > buffer.Length){
throw new ArgumentException("Invalid argument 'count' value.");
}
if((m_AccessMode & FileAccess.Read) == 0){
throw new NotSupportedException();
}
while(true){
// Read next quoted-printable line and decode it.
if(m_DecodedOffset >= m_DecodedCount){
m_DecodedOffset = 0;
m_DecodedCount = 0;
SmartStream.ReadLineAsyncOP readLineOP = new SmartStream.ReadLineAsyncOP(new byte[32000],SizeExceededAction.ThrowException);
m_pStream.ReadLine(readLineOP,false);
// IO error reading line.
if(readLineOP.Error != null){
throw readLineOP.Error;
}
// We reached end of stream.
else if(readLineOP.BytesInBuffer == 0){
return 0;
}
// Decode quoted-printable line.
else{
// Process bytes.
bool softLineBreak = false;
int lineLength = readLineOP.LineBytesInBuffer;
for(int i=0;i<readLineOP.LineBytesInBuffer;i++){
byte b = readLineOP.Buffer[i];
// We have soft line-break.
if(b == '=' && i == (lineLength - 1)){
softLineBreak = true;
}
// We should have =XX hex-byte.
else if(b == '='){
byte b1 = readLineOP.Buffer[++i];
byte b2 = readLineOP.Buffer[++i];
byte b3 = 0;
if(byte.TryParse(new string(new char[]{(char)b1,(char)b2}),System.Globalization.NumberStyles.HexNumber,null,out b3)){
m_pDecodedBuffer[m_DecodedCount++] = b3;
}
// Not hex number, leave it as it is.
else{
m_pDecodedBuffer[m_DecodedCount++] = (byte)'=';
m_pDecodedBuffer[m_DecodedCount++] = b1;
m_pDecodedBuffer[m_DecodedCount++] = b2;
}
}
// Normal char.
else{
m_pDecodedBuffer[m_DecodedCount++] = b;
}
}
// Add hard line break only if there was one in original data.
if(readLineOP.LineBytesInBuffer != readLineOP.BytesInBuffer && !softLineBreak){
m_pDecodedBuffer[m_DecodedCount++] = (byte)'\r';
m_pDecodedBuffer[m_DecodedCount++] = (byte)'\n';
}
}
}
// We have some decoded data, return it.
if(m_DecodedOffset < m_DecodedCount){
int countToCopy = Math.Min(count,m_DecodedCount - m_DecodedOffset);
Array.Copy(m_pDecodedBuffer,m_DecodedOffset,buffer,offset,countToCopy);
m_DecodedOffset += countToCopy;
return countToCopy;
}
}
}
