Jon Cole's WebLog : Sockets

Sample Asynchronous SslStream Client/Server Implementation

joncole — Wed, 13 Jun 2007 22:01:00 GMT

I was recently asked about sample code for the System.Net.Security.SslStream using the asynchronous APIs. I searched the web and couldn't find anything significant, so I decided to write some that included the asynchronous usage of the TcpListenter and TcpClient objects (both in the System.Net.Sockets namespace). In this post, I will show both the client and server side of the picture.

The person that was requesting this sample code seemed pretty anxious to get it, so I pumped this out pretty quickly, and as such, there are probably some bugs in it – please let me know of any you find and I will fix them. My goal here is to introduce the concepts and is not to provide production ready code. There are some things that I plan on changing about this code, but this should be a good starting place for anyone unfamiliar with the usage. Watch for “To Do Items” sections where I try to call out some of the things that I would like to add at some point, but you may need to add to your own code in the mean time…

To start, here is some helper code that is shared between client and server code.

Common Code:

The delegate function definition is used to notify you that a secure connection attempt is either ready for use or that an asynchronous error occurred. The SecureConnectionResults class is merely a holder for the results. You will need to provide an implementation of this delegate function.

When you delegate function is called, you will need to check for any asynchronous exception that may have occurred by looking at the SecureConnectionResults.AsyncException property. If it is null, then the SslStream object should be ready for use. Also, you will want to note that the SecureConnectionResultsCallback will be invoked on a Threadpool thread, so you won’t want to hold onto that thread permanently as it is a limited resource.

To Do Items:

· May also want to expose the underlying socket through the SecureConnectionResults object. This would allow you to change socket options or switch back to an unencrypted network connection if you so desire.

using System;

using System.Net.Security;

public delegate void SecureConnectionResultsCallback(object sender, SecureConnectionResults args);

public class SecureConnectionResults

{

private SslStream secureStream;

private Exception asyncException;

internal SecureConnectionResults(SslStream sslStream)

{

this.secureStream = sslStream;

}

internal SecureConnectionResults(Exception exception)

{

this.asyncException = exception;

}

public Exception AsyncException{get{return asyncException;}}

public SslStream SecureStream{get{return secureStream;}}

}

Server Code:

Here is my implementation of a TcpListener that accepts a connection and then initiates the SSL handshake immediately (by calling SslStream.BeginAuthenticateAsServer from within the OnAcceptConnection callback). This code automatically handles both IPv6 and IPv4 for you – make sure to read the “To Do Items”. If you aren't interested in reading all of the code, the bulk of the work is done inside the StartConnecting, OnAcceptConnection and OnAuthenticateAsServer functions.

To Do Items:

· I haven’t added any substantial error handling to this code.

o For example, you might be able to bind the IPv4 socket to the port but an error could occur when trying to bind the IPv6 socket to that same port (i.e. - it is taken by another application on IPv6 but not on IPv4).

· When on Windows Vista or later, use a single socket to listen for both IPv4 and IPv6 – this avoids the binding problem previously discussed.

· Another example would be that a fatal socket error could happen in OnAcceptConnection or OnAuthenticateAsServer that should result in the entire object being invalidated. I will leave it up to you to add these details for now, but will try to update the code when I have time.

· Thread safety. I am not doing any locking inside the object and so you could see funny results.

o For example, you shutdown the object while a callback is in progress.

using System;

using System.Net;

using System.Net.Sockets;

using System.Net.Security;

using System.Security.Cryptography.X509Certificates;

using System.Security.Authentication;

public class SecureTcpServer : IDisposable

{

X509Certificate serverCert;

RemoteCertificateValidationCallback certValidationCallback;

SecureConnectionResultsCallback connectionCallback;

AsyncCallback onAcceptConnection;

AsyncCallback onAuthenticateAsServer;

bool started;

int listenPort;

TcpListener listenerV4;

TcpListener listenerV6;

int disposed;

bool clientCertificateRequired;

bool checkCertifcateRevocation;

SslProtocols sslProtocols;

public SecureTcpServer(int listenPort, X509Certificate serverCertificate,

SecureConnectionResultsCallback callback)

:this(listenPort,serverCertificate,callback,null)

{

}

public SecureTcpServer(int listenPort, X509Certificate serverCertificate,

SecureConnectionResultsCallback callback,

RemoteCertificateValidationCallback certValidationCallback)

{

if (listenPort < 0 || listenPort > UInt16.MaxValue)

throw new ArgumentOutOfRangeException("listenPort");

if (serverCertificate == null)

throw new ArgumentNullException("serverCertificate");

if (callback == null)

throw new ArgumentNullException("callback");

onAcceptConnection = new AsyncCallback(OnAcceptConnection);

onAuthenticateAsServer = new AsyncCallback(OnAuthenticateAsServer);

this.serverCert = serverCertificate;

this.certValidationCallback = certValidationCallback;

this.connectionCallback = callback;

this.listenPort = listenPort;

this.disposed = 0;

this.checkCertifcateRevocation = false;

this.clientCertificateRequired = false;

this.sslProtocols = SslProtocols.Default;

}

~SecureTcpServer()

{

Dispose();

}

public SslProtocols SslProtocols

{

get { return sslProtocols; }

set { sslProtocols = value; }

}

public bool CheckCertifcateRevocation

{

get { return checkCertifcateRevocation; }

set { checkCertifcateRevocation = value; }

}

public bool ClientCertificateRequired

{

get { return clientCertificateRequired; }

set { clientCertificateRequired = value; }

}

public void StartListening()

{

if(started)

throw new InvalidOperationException("Already started...");

IPEndPoint localIP;

if (Socket.SupportsIPv4 && listenerV4 == null)

{

localIP = new IPEndPoint(IPAddress.Any, listenPort);

Console.WriteLine("SecureTcpServer: Started listening on {0}", localIP);

listenerV4 = new TcpListener(localIP);

}

if(Socket.OSSupportsIPv6 && listenerV6 == null)

{

localIP = new IPEndPoint(IPAddress.IPv6Any, listenPort);

Console.WriteLine("SecureTcpServer: Started listening on {0}", localIP);

listenerV6 = new TcpListener(localIP);

}

if(listenerV4 != null)

{

listenerV4.Start();

listenerV4.BeginAcceptTcpClient(onAcceptConnection,listenerV4);

}

if(listenerV6 != null)

{

listenerV6.Start();

listenerV6.BeginAcceptTcpClient(onAcceptConnection,listenerV6);

}

started = true;

}

public void StopListening()

{

if (!started)

return;

started = false;

if (listenerV4 != null)

listenerV4.Stop();

if (listenerV6 != null)

listenerV6.Stop();

}

void OnAcceptConnection(IAsyncResult result)

{

TcpListener listener = result.AsyncState as TcpListener;

TcpClient client = null;

SslStream sslStream = null;

try

{

if (this.started)

{

//start accepting the next connection...

listener.BeginAcceptTcpClient(this.onAcceptConnection, listener);

}

else

{

//someone called Stop() - don't call EndAcceptTcpClient because

//it will throw an ObjectDisposedException

return;

}

//complete the last operation...

client = listener.EndAcceptTcpClient(result);

bool leaveStreamOpen = false;//close the socket when done

if (this.certValidationCallback != null)

sslStream = new SslStream(client.GetStream(), leaveStreamOpen, this.certValidationCallback);

else

sslStream = new SslStream(client.GetStream(), leaveStreamOpen);

sslStream.BeginAuthenticateAsServer(this.serverCert,

this.clientCertificateRequired,

this.sslProtocols,

this.checkCertifcateRevocation,//checkCertifcateRevocation

this.onAuthenticateAsServer,

sslStream);

}

catch (Exception ex)

{

if (sslStream != null)

{

sslStream.Dispose();

sslStream = null;

}

this.connectionCallback(this, new SecureConnectionResults(ex));

}

void OnAuthenticateAsServer(IAsyncResult result)

{

SslStream sslStream = null;

try

{

sslStream = result.AsyncState as SslStream;

sslStream.EndAuthenticateAsServer(result);

this.connectionCallback(this, new SecureConnectionResults(sslStream));

}

catch (Exception ex)

{

if (sslStream != null)

{

sslStream.Dispose();

sslStream = null;

}

this.connectionCallback(this, new SecureConnectionResults(ex));

}

public void Dispose()

{

if (System.Threading.Interlocked.Increment(ref disposed) == 1)

{

if (this.listenerV4 != null)

listenerV4.Stop();

if (this.listenerV6 != null)

listenerV6.Stop();

listenerV4 = null;

listenerV6 = null;

GC.SuppressFinalize(this);

}

Client Code:

The client code is similar to the server code in that it tries to abstract you from handling the connecting and SSL negotiation. The remoteHostName parameter is used when validating the server’s certificate. If the name you pass in doesn’t match the name on the server’s certificate, you will get certificate errors (i.e. System.Net.Security.SslPolicyErrors.RemoteCertificateNameMismatch). Again, if you really only want to look at the most important parts of the code, focus on the StartConnecting, OnConnected and OnAuthenticateAsClient functions.

To Do Items:

· Change StartConnecting so that it doesn’t require a single IPEndpoint. It would be nice if the code just did an asynchronous DNS lookup for you based on the host name and then automatically connected to any of the resolved addresses (regardless of IPv4 or IPv6)

· I haven’t added any substantial error handling to this code.

o An example would be that a fatal error could happen that should result in the entire object being invalidated. I will leave it up to you to add these details for now, but will try to update the code when I have time.

· Thread safety. I am not doing any locking inside the object and so you could see funny results.

using System;

using System.Net;

using System.Net.Sockets;

using System.Net.Security;

using System.Security.Cryptography.X509Certificates;

using System.Security.Authentication;

public class SecureTcpClient : IDisposable

{

X509CertificateCollection clientCertificates;

RemoteCertificateValidationCallback certValidationCallback;

SecureConnectionResultsCallback connectionCallback;

bool checkCertificateRevocation;

AsyncCallback onConnected;

AsyncCallback onAuthenticateAsClient;

TcpClient client;

IPEndPoint remoteEndPoint;

string remoteHostName;

SslProtocols protocols;

int disposed;

public SecureTcpClient(SecureConnectionResultsCallback callback)

: this(callback,null,SslProtocols.Default)

{

}

public SecureTcpClient(SecureConnectionResultsCallback callback,

RemoteCertificateValidationCallback certValidationCallback)

: this(callback, certValidationCallback, SslProtocols.Default)

{

}

public SecureTcpClient(SecureConnectionResultsCallback callback,

RemoteCertificateValidationCallback certValidationCallback,

SslProtocols sslProtocols)

{

if (callback == null)

throw new ArgumentNullException("callback");

onConnected = new AsyncCallback(OnConnected);

onAuthenticateAsClient = new AsyncCallback(OnAuthenticateAsClient);

this.certValidationCallback = certValidationCallback;

this.connectionCallback = callback;

protocols = sslProtocols;

this.disposed = 0;

}

~SecureTcpClient()

{

Dispose();

}

public bool CheckCertificateRevocation

{

get { return checkCertificateRevocation; }

set {checkCertificateRevocation = value;}

}

public void StartConnecting(string remoteHostName, IPEndPoint remoteEndPoint)

{

StartConnecting(remoteHostName,remoteEndPoint,null);

}

public void StartConnecting(string remoteHostName, IPEndPoint remoteEndPoint,

X509CertificateCollection clientCertificates)

{

if (string.IsNullOrEmpty(remoteHostName))

throw new ArgumentException("Value cannot be null or empty","remoteHostName");

if (remoteEndPoint == null)

throw new ArgumentNullException("remoteEndPoint");

Console.WriteLine("Client connecting to: {0}", remoteEndPoint);

this.clientCertificates = clientCertificates;

this.remoteHostName = remoteHostName;

this.remoteEndPoint = remoteEndPoint;

if (client != null)

client.Close();

client = new TcpClient(remoteEndPoint.AddressFamily);

client.BeginConnect(remoteEndPoint.Address,

remoteEndPoint.Port,

this.onConnected,null);

}

public void Close()

{

Dispose();

}

void OnConnected(IAsyncResult result)

{

SslStream sslStream = null;

try

{

bool leaveStreamOpen = false;//close the socket when done

if (this.certValidationCallback != null)

sslStream = new SslStream(client.GetStream(), leaveStreamOpen, this.certValidationCallback);

else

sslStream = new SslStream(client.GetStream(), leaveStreamOpen);

sslStream.BeginAuthenticateAsClient(this.remoteHostName,

this.clientCertificates,

this.protocols,

this.checkCertificateRevocation,

this.onAuthenticateAsClient,

sslStream);

}

catch (Exception ex)

{

if (sslStream != null)

{

sslStream.Dispose();

sslStream = null;

}

this.connectionCallback(this,new SecureConnectionResults(ex));

}

void OnAuthenticateAsClient(IAsyncResult result)

{

SslStream sslStream = null;

try

{

sslStream = result.AsyncState as SslStream;

sslStream.EndAuthenticateAsClient(result);

this.connectionCallback(this,new SecureConnectionResults( sslStream));

}

catch (Exception ex)

{

if (sslStream != null)

{

sslStream.Dispose();

sslStream = null;

}

this.connectionCallback(this, new SecureConnectionResults(ex));

}

public void Dispose()

{

if (System.Threading.Interlocked.Increment(ref disposed) == 1)

{

if (client != null)

{

client.Close();

client = null;

}

GC.SuppressFinalize(this);

}

Sample Program:

Here is a very simple program that demonstrates the use of these objects.

using System;

using System.IO;

using System.Net;

using System.Threading;

using System.Net.Sockets;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Net.Security;

class Program

{

static void Main(string[] args)

{

SecureTcpServer server = null;

SecureTcpClient client = null;

try

{

int port = 8889;

RemoteCertificateValidationCallback certValidationCallback = null;

certValidationCallback = new RemoteCertificateValidationCallback(IgnoreCertificateErrorsCallback);

string certPath = System.Reflection.Assembly.GetEntryAssembly().Location;

certPath = Path.GetDirectoryName(certPath);

certPath = Path.Combine(certPath, "serverCert.cer");

Console.WriteLine("Loading Server Cert From: " + certPath);

X509Certificate serverCert = X509Certificate.CreateFromCertFile(certPath);

server = new SecureTcpServer(port, serverCert,

new SecureConnectionResultsCallback(OnServerConnectionAvailable));

server.StartListening();

client = new SecureTcpClient(new SecureConnectionResultsCallback(OnClientConnectionAvailable),

certValidationCallback);

client.StartConnecting("localhost", new IPEndPoint(IPAddress.Loopback, port));

}

catch (Exception ex)

{

Console.WriteLine(ex);

}

//sleep to avoid printing this text until after the callbacks have been invoked.

Thread.Sleep(4000);

Console.WriteLine("Press any key to continue...");

Console.ReadKey();

if (server != null)

server.Dispose();

if (client != null)

client.Dispose();

}

static void OnServerConnectionAvailable(object sender, SecureConnectionResults args)

{

if (args.AsyncException != null)

{

Console.WriteLine(args.AsyncException);

return;

}

SslStream stream = args.SecureStream;

Console.WriteLine("Server Connection secured: " + stream.IsAuthenticated);

StreamWriter writer = new StreamWriter(stream);

writer.AutoFlush = true;

writer.WriteLine("Hello from server!");

StreamReader reader = new StreamReader(stream);

string line = reader.ReadLine();

Console.WriteLine("Server Recieved: '{0}'", line == null ? "<NULL>" : line);

writer.Close();

reader.Close();

stream.Close();

}

static void OnClientConnectionAvailable(object sender, SecureConnectionResults args)

{

if (args.AsyncException != null)

{

Console.WriteLine(args.AsyncException);

return;

}

SslStream stream = args.SecureStream;

Console.WriteLine("Client Connection secured: " + stream.IsAuthenticated);

StreamWriter writer = new StreamWriter(stream);

writer.AutoFlush = true;

writer.WriteLine("Hello from client!");

StreamReader reader = new StreamReader(stream);

string line = reader.ReadLine();

Console.WriteLine("Client Recieved: '{0}'", line == null ? "<NULL>" : line);

writer.Close();

reader.Close();

stream.Close();

}

static bool IgnoreCertificateErrorsCallback(object sender,

X509Certificate certificate,

X509Chain chain,

SslPolicyErrors sslPolicyErrors)

{

if (sslPolicyErrors != SslPolicyErrors.None)

{

Console.WriteLine("IgnoreCertificateErrorsCallback: {0}", sslPolicyErrors);

//you should implement different logic here...

if ((sslPolicyErrors & SslPolicyErrors.RemoteCertificateChainErrors) != 0)

{

foreach (X509ChainStatus chainStatus in chain.ChainStatus)

{

Console.WriteLine("\t" + chainStatus.Status);

}

//returning true tells the SslStream object you don't care about any errors.

return true;

}

Note that if you don’t have a certificate for testing this code, you can create a certificate using the MakeCert.exe tool, which ships with the Visual Studio SDK.

Simple Message Framing Sample for TCP Socket - Part 2 (Asynchronous)

joncole — Tue, 25 Apr 2006 22:23:00 GMT

As a follow up to my last post (http://blogs.msdn.com/joncole/archive/2006/03/20/555721.aspx) I decided to add some sample code for implementing an asynchronous version of ReadMessage. All of the same rules apply as discussed in my previous post, but we now have more code we have to create in order to maintain state across calls to our handling code. I have chosen not to implement the sending of a message asynchronously because the reading of a message asynchronously is much more interesting.

We also have the same basic logic as the synchronous implementation (read size, then read the body) but we have to keep state across multiple calls to our code that handles the arrival of data.

Note: There are some special cases related to this sample code that you will need to handle (or at least take into consideration)

1) Local socket is closed by another thread. This could result in an ObjectDisposedException being thrown from this code when accessing the socket.

2) Remote side resets the connection. This results in a SocketException being thrown when using the socket to send or receive data

3) Simultaneous duplicate calls to ReadMessage or ReadMessageAsync on the same socket should not be allowed. Doing this will result very odd behavior. Some examples are: you could potentially run into chopped messages, apparent hangs (one side expecting to read more data than the other side is going to send), or OutOfMemoryExceptions (because you interpret a portion of the message body of one request to be the message size of another request and allocate too much memory). Basically you are causing an alignment problem in your stream protocol parsing, which breaks the entire app.

First, we need a couple of objects for holding our state and some helper code to handle the asynchronous notification to the user that a message has arrived.

//**********************************************

//the definition of a function that the user has to give us for us to

//notify him/her that a message has arrived.

//**********************************************
public delegate void ReadMessageAsyncCallback(ReadMessageEventArgs e);

//**********************************************
//This is the argument passed to the above delegate
//**********************************************
public class ReadMessageEventArgs : EventArgs
{

internal ReadMessageEventArgs(string msg)

{

Message = msg;

Error = null;

}

internal ReadMessageEventArgs(Exception err)

{

Error = err;

Message = null;

}

public readonly Exception Error;

public readonly string Message;

}

//**********************************************
//this class keeps track of our state during the read operation

//**********************************************
internal class ReadMessageAsyncState : IDisposable

{

public ReadMessageAsyncState(Socket socket, ReadMessageAsyncCallback callback)

{

if (socket == null)

throw new ArgumentNullException("socket");

if (callback == null)

throw new ArgumentNullException("callback");

userSocket = socket;

userCallback = callback;

buffer = new byte[4];

bytesReceived = 0;

messageSize = -1;

}

public void Dispose()

{

userSocket = null;

userCallback = null;

buffer = null;

}

public Socket userSocket;

public ReadMessageAsyncCallback userCallback;

public int bytesReceived;

public byte[] buffer;

public int messageSize;

}

Now that we have defined all of the helper objects lets get to the new ReadMessageAsync function implementation. This is the function that would be called to start the async read message process. It basically just creates the async state object and then starts an async read on the socket. Note that in this implementation I have not provided a way to cancel the asynchronous operation in case where other side of stream is behaving badly. You may need to consider doing so for your application.

public static void ReadMessageAsync(Socket socket,

ReadMessageAsyncCallback callback)

{

ReadMessageAsyncState state = new ReadMessageAsyncState(socket, callback);

socket.BeginReceive(state.buffer,

0, //offset

state.buffer.Length, //how much data can be read

SocketFlags.None, new AsyncCallback(OnReceive), state);

}

Now, all the magic really happens in the OnReceive function (my callback passed to the BeginReceive calls on the socket). This fuction is what is responsible for starting the next read on the socket if more data is needed, it calls the user callback when the entire message has been received and it handles any error and sets it on the ReadMessageEventArgs object.

static void OnReceive(IAsyncResult ar)

{

ReadMessageAsyncState state = ar.AsyncState as ReadMessageAsyncState;

try

{

int count = state.userSocket.EndReceive(ar);

state.bytesReceived += count;

if (state.messageSize == -1)//we are still reading the size of the data

{

if (count == 0)

throw new ProtocolViolationException("The remote peer closed the connection while reading the message size.");

if (state.bytesReceived == 4)//we have received the entire message size information

{

//read the size of the message

state.messageSize = BitConverter.ToInt32(state.buffer, 0);

if (state.messageSize < 0)

{

throw new ProtocolViolationException("The remote peer sent a negative message size.");

}

//we should do some size validation here also (e.g. restrict incoming messages to x bytes long)

state.buffer = new Byte[state.messageSize];

//reset the bytes received back to zero

//because we are now switching to reading the message body

state.bytesReceived = 0;

}

if (state.messageSize != 0)

{

//we need more data - could be more of the message size information

//or it could be the message body. The only time we won't need to

//read more data is if the message size == 0

state.userSocket.BeginReceive(state.buffer,

state.bytesReceived, //offset where data can be written

state.buffer.Length - state.bytesReceived, //how much data can be read into remaining buffer

SocketFlags.None, new AsyncCallback(OnReceive), state);

}

else

{

//we have received a zero length message, notify the user...

ReadMessageEventArgs args = new ReadMessageEventArgs(String.Empty);

state.userCallback(args);

state.Dispose();

}

else //we are reading the body of the message

{

if (state.bytesReceived == state.messageSize) //we have the entire message

{

//notify the user

state.userCallback(new ReadMessageEventArgs(Encoding.ASCII.GetString(state.buffer)));

//free up our reference to the socket, buffer and the callback object.

state.Dispose();

}

else //need more data.

{

if (count == 0)

throw new ProtocolViolationException("The remote peer closed the connection before the entire message was received");

state.userSocket.BeginReceive(state.buffer,

state.bytesReceived, //offset where data can be written

state.buffer.Length - state.bytesReceived, //how much data can be read into remaining buffer

SocketFlags.None, new AsyncCallback(OnReceive), state);

}

catch (Exception ex)

{

ReadMessageEventArgs args = new ReadMessageEventArgs(ex);

state.userCallback(args);

state.Dispose();

}

I would also recommend that you read Malar Chinnusamy's blog on socket programming considerations.

Simple Message Framing Sample for TCP Socket

joncole — Mon, 20 Mar 2006 20:31:00 GMT

A common misunderstanding for developers new to network programming over TCP sockets is how messages are sent and received. I frequently hear the statement that "my data is not arriving on the other side of the socket in the same format that I sent it." The most common cause of this is because the TCP protocol does not guarantee that it will keep message boundaries. In other words, you could send "Hello World" in a single call to Send(), but the other side of the socket stream may have to do multiple Receive() calls on the socket to get all of the data (the first Receive might return "He" and the second "llo World"). Data might also be concatenated together into a single TCP packet on the wire. The client may send "Hello World" and "I am in Seattle" in different calls to Send(), but the other side of the socket may receive it with a single call to Receive() in the format "Hello WorldI am in Seattle".

I thought I would give a simple example that shows how to frame your message so that it comes out on the other side of the network stream in the same format in which it was sent. Your implementation may need to be more complex than what I have given here.

Also, I have written this in C# and please be aware that this code does not handle errors in the stream and does not do parameter checking. If the connection get's dropped in the middle of a mesage or if the msg being sent is greater than what can be sent with an integer size, you will see funny results. Here, I am trying to keep the code simple and to the point.

      static void SendMessage(Socket socket, string msg)
        {
            byte[] data = Encoding.ASCII.GetBytes(msg);
            byte[] sizeinfo = new byte[4];

            //could optionally call BitConverter.GetBytes(data.length);
            sizeinfo[0] = (byte)data.Length;
            sizeinfo[1] = (byte)(data.Length >> 8);
            sizeinfo[2] = (byte)(data.Length >> 16);
            sizeinfo[3] = (byte)(data.Length >> 24);

            socket.Send(sizeinfo);
            socket.Send(data);
        }

        //note, this function does not handle closed connections in the middle of a message...
        static string ReadMessage(Socket socket)
        {
            byte[] sizeinfo = new byte[4];

//read the size of the message
int totalread = 0, currentread = 0;

currentread = totalread = socket.Receive(sizeinfo);

            while (totalread < sizeinfo.Length && currentread > 0)
            {
                currentread = socket.Receive(sizeinfo,
                          totalread, //offset into the buffer
                          sizeinfo.Length - totalread, //max amount to read
                          SocketFlags.None);

totalread += currentread;
}

int messagesize = 0;

            //could optionally call BitConverter.ToInt32(sizeinfo, 0);
            messagesize |= sizeinfo[0];
            messagesize |= (((int)sizeinfo[1]) << 8);
            messagesize |= (((int)sizeinfo[2]) << 16);
            messagesize |= (((int)sizeinfo[3]) << 24);

            //create a byte array of the correct size
            //note: there really should be a size restriction on
            //              messagesize because a user could send
            //              Int32.MaxValue and cause an OutOfMemoryException
            //              on the receiving side. maybe consider using a short instead
            //              or just limit the size to some reasonable value
            byte[] data = new byte[messagesize];

            //read the first chunk of data
            totalread = 0;
            currentread = totalread = socket.Receive(data,
                         totalread, //offset into the buffer
                        data.Length - totalread, //max amount to read
                        SocketFlags.None);

            //if we didn't get the entire message, read some more until we do
            while (totalread < messagesize && currentread > 0)
            {
                currentread = socket.Receive(data,
                         totalread, //offset into the buffer
                        data.Length - totalread, //max amount to read
                        SocketFlags.None);
                totalread += currentread;
            }

return Encoding.ASCII.GetString(data, 0, totalread);
}

I would also recommend that you read Malar Chinnusamy's blog on socket programming considerations