disconnect/close a client

Question

I have a simple client-server application which works like this: the server is always listening (in a separate thread) for a client connection (which sends the name of process that it wants the server to kill).

Here is the server:

private void btnStart_Click(object sender, EventArgs e)
{
  _port = int.Parse(comboBoxPorts.SelectedItem.ToString());

  _tcpListener = new TcpListener(_ipAddress, _port);

  _keepRunning = true;
  _listenerThread = new Thread(Listen);
  HandleListenerThreadStartListenEvent += HandleListenerThreadStartedEventMethod;
  ListenerThreadStartedEvent += HandleListenerThreadStartListenEvent;
  _listenerThread.Start();
}

private void btnStop_Click(object sender, EventArgs e)
{ 
  if (_tcpListener != null)
  {
    _keepRunning = false; 

    if (_tcpListener.Server.Connected)
    {
      _tcpListener.Server.Disconnect(true); 
    } 

    _tcpListener.Stop(); 
  }

  labelServerStatus.Text = "Server is stopped";   
  comboBoxPorts.Enabled = true; 
  btnStart.Enabled = true; 
  btnStop.Enabled = false; 
} 

private void Listen()
{
  try
  {
    _tcpListener.Start();
    OnListenerThreadStartListenEvent(); // just update the GUI
  }
  catch(Exception e)
  {
    MessageBox.Show("Port " + _port + " is NOT available." + Environment.NewLine +
                    "Please choose another one: " + e.Message);
    return;
  }

  _keepRunning = true;
  string ballonMessage = "Socket Server Running at " + _ipAddress + ", port: " + _port;
  notifyIcon1.ShowBalloonTip(2000, "Simplex Listener", ballonMessage, ToolTipIcon.Info);

  while (_keepRunning)
  {
    try
    {          
      #region using AcceptSocket()

      _clientSocket = _tcpListener.AcceptSocket();
      string checkString = string.Empty;
      IPAddress ipOfClient = ((IPEndPoint) _clientSocket.LocalEndPoint).Address;
      notifyIcon1.ShowBalloonTip(2000, "Simplex Listener", "New client has connected from ip " + ipOfClient, ToolTipIcon.Info);

      byte[] buffer = new byte[SIZE_OF_BUFFER];
      int bytesReceived = _clientSocket.Receive(buffer);

      // Concatenate chars as bytes to a received string.
      for (int i = 0; i < bytesReceived; i++)
        checkString += Convert.ToChar(buffer[i]);



      //..... getting the name of process and kill it (and than open it...
      RestartProcess(nameOfProcess, windowName, pathToExeFile);

      // Client is waiting to know operation is complete- so send him some char...
      ASCIIEncoding encoder = new ASCIIEncoding();
      _clientSocket.Send(encoder.GetBytes("v"));
      _clientSocket.Disconnect(true);
      _clientSocket.Close();
      #endregion
    }
    catch (Exception )
    {    
    }
  }
}

The client side:

public void RestartTheSoftwareInServerComputer(string ipOfServer, int portNumber)
{
  TcpClient client = new TcpClient();

  if (_serverEndPoint == null)
  {
    _serverEndPoint = new IPEndPoint(IPAddress.Parse(ipOfServer), portNumber);     
  }

  client.Connect(_serverEndPoint);

  // Send the command to the server:
  NetworkStream clientStream = client.GetStream();
  ASCIIEncoding encoder = new ASCIIEncoding();
  byte[] buffer = encoder.GetBytes("....detailsOfProcess....");

  clientStream.Write(buffer, 0, buffer.Length);
  clientStream.Flush();

  // Now, wait for the server's response [which means the process had been restart].
  NetworkStream stream = client.GetStream();
  byte[] bytes = new byte[5];
  stream.Read(bytes, 0, 5);
  string response = Encoding.UTF8.GetString(bytes, 0, 1);

  if (response.Equals("x"))
  {
    throw new Exception("Failed to restart X software.");
  }

  stream.Close();
  client.Close();
}

When I stop and restart the server (when no client had connected), then everything is OK.

The problem is when the server got some client connected, and is restarted, then the client has disconnected and the server needs to be restarted. When we hit the "START SERVER" again it will get the exception:

Only one usage of each socket address (protocol/network address/port) is normally permitted.

How should I close the port?

Answer 1

When you exit your server, you should call _tcpListener.Stop() to close the main socket that the server is listening on.

Edit: You could also try to call _listenerThread.Join() in your stop button click, to wait for the listener thread to finish, before starting the next one.

private void btnStop_Click(object sender, EventArgs e)
{ 
  if (_tcpListener != null)
  {
    _keepRunning = false;

    if (_tcpListener.Server.Connected)
    {
      _tcpListener.Server.Disconnect(true); 
      _tcpListener.Stop();
      if (_clientSocket != null)
      {
        _clientSocket.Close();
        _clientSocket = null;
      }
      _listenerThread.Join();
    }
  }

  labelServerStatus.Text = "Server is stopped";   
  comboBoxPorts.Enabled = true; 
  btnStart.Enabled = true; 
  btnStop.Enabled = false; 
} 

EDIT 2:

here is a windows form that does similar to your server. I didn't need a client, just use "telnet localhost 49152" from a command prompt to 'pretend' to be the client connecting.

public partial class Form1 : Form
{
    private TcpListener _tcpListener;
    private bool _keepRunning;
    private Thread _listenerThread;
    private Socket _clientSocket;


    public Form1()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        var address = IPAddress.Parse("127.0.0.1");
        _tcpListener = new TcpListener(address, 49152);

        _keepRunning = true;
        _listenerThread = new Thread(Listen);
        _listenerThread.Start();

        button1.Enabled = false;
        button2.Enabled = true;
    }

    private void Listen()
    {
        try
        {
            _tcpListener.Start();
        }
        catch (Exception e)
        {
            MessageBox.Show(e.Message);
            return;
        }

        _keepRunning = true;

        while (_keepRunning)
        {
            try
            {
                _clientSocket = _tcpListener.AcceptSocket();

                var buffer = new byte[8192];
                var bytesReceived = _clientSocket.Receive(buffer);
                var checkString = String.Empty;

                if (_keepRunning)
                {
                    // bytesReceived can be 0 if the remote socket disconnected
                    if (bytesReceived > 0)
                    {
                        checkString = Encoding.ASCII.GetString(buffer, 0, bytesReceived);

                        // Client is waiting to know operation is complete- so send him some char...
                        var encoder = new ASCIIEncoding();
                        _clientSocket.Send(encoder.GetBytes("v"));
                    }
                    if (_clientSocket.Connected) _clientSocket.Disconnect(true);
                }
                _clientSocket.Close();
            }
            catch (Exception ex)
            {
                // really should do something with these exceptions
            }
        }
    }

    private void button2_Click(object sender, EventArgs e)
    {
        if (_tcpListener != null)
        {
            _keepRunning = false;

            if (_tcpListener.Server.Connected)
            {
                _tcpListener.Server.Disconnect(true);
            }
            _tcpListener.Stop();

            if (_clientSocket != null)
            {
                _clientSocket.Close();
                _clientSocket = null;
            }
            _listenerThread.Join();
        }

        button1.Enabled = true;
        button2.Enabled = false;
    }
}

There are a lot of problems with this code, e.g. sharing variables across threads etc. but on my machine the Join doesn't seem to block for any length of time. The problem with _keepRunning is that on certain systems it's possible for one thread to not see the change from true to false, because it gets optimised or cached. You should really use some form of thread synchronisation, make it volatile, or wrap it in a lock etc. I'd suggest you have a read here about this. I'd also suggest you have a read up on Sockets too, or if as other commenters have mentioned, if you aren't interested in learning about all the idiosyncrasies of sockets and threading, perhaps you should look for a higher level library that hides it all?