TCP Socket Server custom class for socket identifier in C#

Question

I've been looking at many tcp client/server examples and would want to know how one can go about creating a method to identify each client. One way I know is through lets say, a log in authentication. I know how to connect, and query a database, but how would I lets say after successful authentication, take the username and say this username is this socket. A class example or simple method would be appreciated as an example. I want to be able to target all connected clients by their username from a database individually.

Example I'm using for server

 using System;

    using System.Collections.Generic;

    using System.Net;

    using System.Net.Sockets;

    using System.Text;



    namespace MultiServer

    {

        class Program

        {

            private static readonly Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            private static readonly List<Socket> clientSockets = new List<Socket>();

            private const int BUFFER_SIZE = 2048;

            private const int PORT = 100;

            private static readonly byte[] buffer = new byte[BUFFER_SIZE];



            static void Main()

            {

                Console.Title = "Server";

                SetupServer();

                Console.ReadLine(); // When we press enter close everything

                CloseAllSockets();

            }



            private static void SetupServer()

            {

                Console.WriteLine("Setting up server...");

                serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT));

                serverSocket.Listen(0);

                serverSocket.BeginAccept(AcceptCallback, null);

                Console.WriteLine("Server setup complete");

            }



            /// <summary>

            /// Close all connected client (we do not need to shutdown the server socket as its connections

            /// are already closed with the clients).

            /// </summary>

            private static void CloseAllSockets()

            {

                foreach (Socket socket in clientSockets)

                {

                    socket.Shutdown(SocketShutdown.Both);

                    socket.Close();

                }



                serverSocket.Close();

            }



            private static void AcceptCallback(IAsyncResult AR)

            {

                Socket socket;



                try

                {

                    socket = serverSocket.EndAccept(AR);

                }

                catch (ObjectDisposedException) // I cannot seem to avoid this (on exit when properly closing sockets)

                {

                    return;

                }



               clientSockets.Add(socket);

               socket.BeginReceive(buffer, 0, BUFFER_SIZE, SocketFlags.None, ReceiveCallback, socket);

               Console.WriteLine("Client connected, waiting for request...");

               serverSocket.BeginAccept(AcceptCallback, null);

            }



            private static void ReceiveCallback(IAsyncResult AR)

            {

                Socket current = (Socket)AR.AsyncState;

                int received;



                try

                {

                    received = current.EndReceive(AR);

                }

                catch (SocketException)

                {

                    Console.WriteLine("Client forcefully disconnected");

                    // Don't shutdown because the socket may be disposed and its disconnected anyway.

                    current.Close(); 

                    clientSockets.Remove(current);

                    return;

                }



                byte[] recBuf = new byte[received];

                Array.Copy(buffer, recBuf, received);

                string text = Encoding.ASCII.GetString(recBuf);

                Console.WriteLine("Received Text: " + text);



                if (text.ToLower() == "get time") // Client requested time

                {

                    Console.WriteLine("Text is a get time request");

                    byte[] data = Encoding.ASCII.GetBytes(DateTime.Now.ToLongTimeString());

                    current.Send(data);

                    Console.WriteLine("Time sent to client");

                }

                else if (text.ToLower() == "exit") // Client wants to exit gracefully

                {

                    // Always Shutdown before closing

                    current.Shutdown(SocketShutdown.Both);

                    current.Close();

                    clientSockets.Remove(current);

                    Console.WriteLine("Client disconnected");

                    return;

                }

                else

                {

                    Console.WriteLine("Text is an invalid request");

                    byte[] data = Encoding.ASCII.GetBytes("Invalid request");

                    current.Send(data);

                    Console.WriteLine("Warning Sent");

                }



                current.BeginReceive(buffer, 0, BUFFER_SIZE, SocketFlags.None, ReceiveCallback, current);

            }

        }

    }

Answer 1

There's a very simple solution to that when you're using the asynchronous callbacks (though I'd strongly recommend switching to a newer approach, or even better, an existing library - raw TCP is hard to do right).

The callback delegate can point to an instance method. This means you can have something like this:

class Client
{
  private readonly Socket socket;
  public readonly byte[] ReceiveBuffer = new byte[BUFFFER_SIZE];

  public Client(Socket socket)
  {
    this.socket = socket;
  }

  public void ReceiveCallback(IAsyncResult AR)
  {
    // Handle the received data as usual
  }
}

And then in your AcceptCallback method, just use a list of Client instead of Socket, and the final BeginReceive call as such:

var client = new Client(socket);
socket.BeginReceive(client.ReceiveBuffer, 0, BUFFER_SIZE, SocketFlags.None, client.ReceiveCallback, 
                    socket);
clients.Add(newClient);

But again, writing custom networking is hard. Use an existing solution if possible - there's plenty to choose from.

Also, the ObjectDisposedExceptions you're getting are because you're doing Shutdown immediately followed by a Close. This is wrong. TCP shutdown is coöperative - you need to wait for the client socket to close before you call Close on your socket. What you're doing is rudely interrupting the connection before it has a chance to resolve itself. Again - TCP is hard to do right, you need to learn how it works very thoroughly.