[pgsqlclient-checkins] pgsqlclient_10/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls.Handshake TlsHandshakeMessage.cs,1.2,1.3

[<car...@us...>]

Update of /cvsroot/pgsqlclient/pgsqlclient_10/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls.Handshake
In directory sc8-pr-cvs1:/tmp/cvs-serv1430

Modified Files:
	TlsHandshakeMessage.cs 
Log Message:
Added more enhacements to the Handshake protocol

Index: TlsHandshakeMessage.cs
===================================================================
RCS file: /cvsroot/pgsqlclient/pgsqlclient_10/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls/Mono.Security.Protocol.Tls.Handshake/TlsHandshakeMessage.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TlsHandshakeMessage.cs	13 Oct 2003 19:13:55 -0000	1.2
--- TlsHandshakeMessage.cs	13 Oct 2003 20:48:03 -0000	1.3
***************
*** 24,32 ****
  
  using System;
  
  namespace Mono.Security.Protocol.Tls.Handshake
  {
! 	#warning "Think on change this for inherit from Stream"
! 	internal class TlsHandshakeMessage
  	{
  		#region FIELDS
--- 24,34 ----
  
  using System;
+ using System.IO;
+ using System.Net;
  
  namespace Mono.Security.Protocol.Tls.Handshake
  {
! 	#warning "Think on implement a base stream class with the same stream methods as this have and remove TlsStreamReader and TlsStreamWriter classes"
! 	internal class TlsHandshakeMessage : Stream
  	{
  		#region FIELDS
***************
*** 37,42 ****
  		private bool				canRead;
  		private bool				canWrite;
! 		private TlsStreamReader		reader;
! 		private TlsStreamWriter		writer;
  
  		#endregion
--- 39,73 ----
  		private bool				canRead;
  		private bool				canWrite;
! 		private MemoryStream		buffer;
! 
! 		#endregion
! 
! 		#region STREAM_PROPERTIES
! 
! 		public override bool CanWrite
! 		{
! 			get { return canWrite; }
! 		}
! 
! 		public override bool CanRead
! 		{
! 			get { return canRead; }
! 		}
! 
! 		public override bool CanSeek
! 		{
! 			get { return buffer.CanSeek; }
! 		}
! 
! 		public override long Position
! 		{
! 			get { return buffer.Position; }
! 			set { buffer.Position = value; }
! 		}
! 
! 		public override long Length
! 		{
! 			get { return buffer.Length; }
! 		}
  
  		#endregion
***************
*** 59,90 ****
  		}
  
! 		public TlsStreamReader Reader
! 		{
! 			get 
! 			{
! 				if (canRead)
! 				{
! 					return reader;
! 				}
! 				throw new InvalidOperationException();
! 			}
! 		}
  
! 		public TlsStreamWriter Writer
  		{
! 			get 
! 			{
! 				if (canWrite)
! 				{
! 					return writer;
! 				}
! 				throw new InvalidOperationException();
! 			}
  		}
  
! 		#endregion
! 
! 		public TlsHandshakeMessage()
  		{
  		}
  
--- 90,105 ----
  		}
  
! 		#endregion
  
! 		#region CONSTRUCTORS
! 
! 		private TlsHandshakeMessage() : base()
  		{
! 			this.buffer	= new MemoryStream(0);
  		}
  
! 		private TlsHandshakeMessage(byte[] data) : base()
  		{
+ 			this.buffer	= new MemoryStream(data, false);
  		}
  
***************
*** 96,102 ****
  			this.handshakeType	= handshakeType;
  			this.contentType	= contentType;
- 			this.writer			= new TlsStreamWriter();
  			this.canRead		= false;
! 			this.canWrite		= true;
  
  			// Fill message contents
--- 111,116 ----
  			this.handshakeType	= handshakeType;
  			this.contentType	= contentType;
  			this.canRead		= false;
! 			this.canWrite		= true;			
  
  			// Fill message contents
***************
*** 105,121 ****
  
  		public TlsHandshakeMessage(TlsSession session, 
! 			TlsHandshakeType handshakeType, 
! 			TlsStreamReader reader)
  		{
  			this.session		= session;
  			this.handshakeType	= handshakeType;
- 			this.reader			= reader;
  			this.canRead		= true;
  			this.canWrite		= false;
! 
  			// Parse message
  			this.Parse();
  		}
  
  		public virtual void UpdateSession()
  		{			
--- 119,264 ----
  
  		public TlsHandshakeMessage(TlsSession session, 
! 			TlsHandshakeType handshakeType, byte[] data) : this(data)
  		{
  			this.session		= session;
  			this.handshakeType	= handshakeType;
  			this.canRead		= true;
  			this.canWrite		= false;
! 						
  			// Parse message
  			this.Parse();
  		}
  
+ 		#endregion
+ 
+ 		#region SPECIFIC_READ_METHODS
+ 
+ 		public new byte ReadByte()
+ 		{
+ 			return (byte)base.ReadByte();
+ 		}
+ 
+ 		public short ReadInt16()
+ 		{
+ 			byte[] bytes = this.ReadBytes(2);
+ 
+ 			return IPAddress.HostToNetworkOrder(BitConverter.ToInt16(bytes, 0));
+ 		}
+ 
+ 		public int ReadInt24()
+ 		{
+ 			byte[] b = this.ReadBytes(3);
+ 			
+ 			return ((b[0] & 0xff) << 16) | ((b[1] & 0xff) << 8) | (b[2] & 0xff);
+ 		}
+ 
+ 		public int ReadInt32()
+ 		{
+ 			byte[] bytes = this.ReadBytes(4);
+ 
+ 			return IPAddress.HostToNetworkOrder(BitConverter.ToInt32(bytes, 0));
+ 		}
+ 
+ 		public long ReadInt64()
+ 		{
+ 			byte[] bytes = this.ReadBytes(8);
+ 						
+ 			return IPAddress.HostToNetworkOrder(BitConverter.ToInt64(bytes, 0));
+ 		}
+ 
+ 		public byte[] ReadBytes(int count)
+ 		{
+ 			byte[] bytes = new byte[count];
+ 			this.Read(bytes, 0, count);
+ 
+ 			return bytes;
+ 		}
+ 
+ 		#endregion
+ 
+ 		#region SPECIFIC_WRITE_METHODS
+ 
+ 		public void Write(byte value)
+ 		{
+ 			WriteByte(value);
+ 		}
+ 
+ 		public void Write(short value)
+ 		{
+ 			byte[] bytes = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder(value));
+ 			Write(bytes);
+ 		}
+ 
+ 		public void WriteInt24(int value)
+ 		{
+ 			int int24 = IPAddress.HostToNetworkOrder(value);
+ 			byte[] content = new byte[3];
+ 				
+ 			System.Array.Copy(BitConverter.GetBytes(int24), 1, content, 0, 3);
+ 
+ 			Write(content);
+ 		}
+ 
+ 		public void Write(int value)
+ 		{
+ 			byte[] bytes = BitConverter.GetBytes((int)IPAddress.HostToNetworkOrder(value));
+ 			Write(bytes);
+ 		}
+ 
+ 		public void Write(long value)
+ 		{
+ 			byte[] bytes = BitConverter.GetBytes((long)IPAddress.HostToNetworkOrder(value));
+ 			Write(bytes);
+ 		}
+ 
+ 		public void Write(byte[] buffer)
+ 		{
+ 			Write(buffer, 0, buffer.Length);
+ 		}
+ 
+ 		#endregion
+ 
+ 		#region STREAM_METHODS
+ 
+ 		public override void Flush()
+ 		{
+ 			buffer.Flush();
+ 		}
+ 
+ 		public override void SetLength(long length)
+ 		{
+ 			buffer.SetLength(length);
+ 		}
+ 
+ 		public override long Seek(long offset, System.IO.SeekOrigin loc)
+ 		{
+ 			return buffer.Seek(offset, loc);
+ 		}
+ 
+ 		public override int Read(byte[] buffer, int offset, int count)
+ 		{
+ 			if (canRead)
+ 			{
+ 				return this.buffer.Read(buffer, offset, count);
+ 			}
+ 			throw new InvalidOperationException("Read operations are not allowed by this stream");
+ 		}
+ 
+ 		public override void Write(byte[] buffer, int offset, int count)
+ 		{
+ 			if (canWrite)
+ 			{
+ 				this.buffer.Write(buffer, offset, count);
+ 			}
+ 			else
+ 			{
+ 				throw new InvalidOperationException("Write operations are not allowed by this stream");
+ 			}
+ 		}
+ 
+ 		#endregion
+ 
+ 		#region METHODS
+ 
  		public virtual void UpdateSession()
  		{			
***************
*** 144,149 ****
  
  				c.Write((byte)HandshakeType);
! 				c.WriteInt24((int)writer.Length);
! 				c.Write(writer.GetBytes());
  
  				result = c.GetBytes();
--- 287,292 ----
  
  				c.Write((byte)HandshakeType);
! 				c.WriteInt24((int)Length);
! 				c.Write(buffer.ToArray());
  
  				result = c.GetBytes();
***************
*** 163,175 ****
  		public void Reset()
  		{
! 			if (canWrite)
! 			{
! 				writer.Reset();
! 			}
! 			if (canRead)
! 			{
! 				reader.Reset();
! 			}
  		}
  	}
  }
--- 306,314 ----
  		public void Reset()
  		{
! 			buffer.SetLength(0);
! 			buffer.Position = 0;
  		}
+ 
+ 		#endregion
  	}
  }