CODEWITHSUNDEEP
c#socketsasynchronousprotocol-buffers
Johnathon Sullinger
Johnathon Sullinger

Reputation: 7414

async Telnet Server data receiving issues

I am writing a telnet server using the async Begin/End methods. The issue that I am having is determining what within my buffer is actual data and what is not. Network coding is a bit new to me, but I've tried to research this and have not been able to find a answer.

public bool Start(IGame game)
{
    // Get our server address information.
    IPHostEntry serverHost = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Any, this.Port);

    // Instance the server socket, bind it to a port and begin listening for connections.
    this._ServerSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
    this._ServerSocket.Bind(serverEndPoint);
    this._ServerSocket.Listen(this.MaxQueuedConnections);

    this._ServerSocket.BeginAccept(new AsyncCallback(Connect), this._ServerSocket);
    return true;
}

private void Connect(IAsyncResult result)
{
    var player = new BasePlayer();
    try
    {
        player.Game = this.Game;
        player.Connection = this._ServerSocket.EndAccept(result);

        lock (this.Connections)
        {
            this.Connections.Add(player);
        }

        // Pass all of the data handling for the player to itself.
        player.Connection.BeginReceive(player.Buffer, 0, player.BufferSize, SocketFlags.None, new AsyncCallback(player.ReceiveData), player);

        // Fetch the next incoming connection.
        this._ServerSocket.BeginAccept(new AsyncCallback(Connect), this._ServerSocket);
    }
    catch (Exception)
    {
    }
}

and then the player.ReceiveData..

public void ReceiveData(IAsyncResult result)
{
    int bytesRead = this.Connection.EndReceive(result);

    if (bytesRead > 0)
    {
        // TODO: Parse data received by the user.

        //Queue the next receive data.
        this.Connection.BeginReceive(this.Buffer, 0, this.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveData), this);
        var str = System.Text.Encoding.Default.GetString(Buffer);
    }
    else
    {
        this.Disconnect(result);
    }
}

So when I call BeginReceive, I need to provide a buffer of a predetermined size. In doing that, I end up with unused bytes in my buffer array. They all have the value of 0, so I am assuming that I can loop through the array and build a new one starting at index 0 and working until I hit a value of 0.

I imagine there is a better way to do this? Can someone please point me in the right direction as to how I should determine what the data is within my buffer or perhaps a way that I can do this without having to use a predetermined buffer size.

Upvotes: 1

Views: 755

Answers (1)

Jon Skeet
Jon Skeet

Reputation: 1500535

So when call BeginReceive, I need to provide a buffer of a predetermined size. In doing that, I end up with unused bytes in my buffer array. They all have the value of 0, so I am assuming that I can loop through the array and build a new one starting at index 0 and working until I hit a value of 0.

No, that's not what you should do. Instead, in your callback (ReceiveData) you're already calling EndReceive - and the result of that is the number of bytes you read. That's how much of the buffer you should use.

However, you should copy the data you've read out of the buffer before you call BeginReceive again, otherwise you may end up with the next bit of data overwriting the just-read data before you get to use it.

So something like:

string text = Encoding.ASCII.GetString(Buffer, 0, bytesRead);
Connection.BeginReceive(this.Buffer, 0, this.BufferSize, SocketFlags.None,
                        new AsyncCallback(ReceiveData), this);

I would not suggest that you use Encoding.Default to convert the bytes to text - instead, you should decide which encoding you're using, and stick to that. If you use an encoding which isn't always one-byte-per-character, you'll end up in a slightly trickier situation, as then you might end up receiving a buffer with part of a character. At that point you need to keep a Decoder which can maintain state about partial characters read.

Upvotes: 1

Related Questions