FD_ISSET does not detect new file descriptor.

bryanhdl · 01-15-2008, 04:58 PM

Hi,

I'm new in Linux and having problem with FD_ISSET to detect second file descriptor for udp socket. There are 2 clients connecting to my udp socket server, I'm setting FD_SET (fdA), FD_SET (fdB) for each client. But the FD_ISSET is only detect the first fdA for the client B (expected FD_ISSET(fdB) is TRUE)

Do you know how to detect activity for fdB?

Thank you,

Bryanhdl

dwhitney67 · 01-15-2008, 10:49 PM

I cannot fully comment on what is causing the issue you are having, however the code below should work; of course, you will need to add the "extras" around it to meet your needs.

If you are planning to support more than two clients, I would recommend that you consider going with a multi-threaded application, where one thread listens for connections, and another thread handles client requests.

PHP Code:



fd_set rfds; 
fd_set rfds_save; 
int fdMax = 0; 
 
FD_ZERO(&rfds_save); 
FD_SET(fdA, &rfds_save); 
fdMax = std::max(fdMax, fdA); 
FD_SET(fdB, &rfds_save); 
fdMax = std::max(fdMax, fdB); 
... 
while ( someCondition ) 
{ 
  rfds = rfds_save; 
 
  if (select(fdMax + 1, &rfds, 0, 0, &timeout) > 0) 
  { 
    if (FD_ISSET(fdA, &rfds)) 
      // activity detected for client A 
 
    else if (FD_ISSET(fdB, &rfds)) 
      // activity detected for client B 
 
    else 
      // disregard 
  } 
}

P.S. If a client disconnects, you will need to update 'rfds_save'.

bryanhdl · 01-16-2008, 10:58 AM

Thank you for your suggestion. I did the same thing like your code for first connection with client A. But when A disconnects, I did not update the rfds_save, so the second connection with client B, I still receive activity on fdA.
To update the rfds_save, do I have to update fdMax?
FD_CLR(fdA, &rfds_save);

Thanks again,
Bryan

dwhitney67 · 01-16-2008, 12:57 PM

Quote:

Originally Posted by bryanhdl

To update the rfds_save, do I have to update fdMax?

You're welcome. I don't know for sure if it is absolutely required to update fdMax, however I always did.

Long ago (4+ years ago) I wrote a multi-threaded application in C++ which enabled the server to handle many client connections. I had one thread whose sole purpose was to accept connections, and maintain this list of connected clients, and to make this information (e.g. fd_set, maxFD, and client objects) available.

Another thread, which performed the select(), and subsequent read() operations for a particular client object, was responsible for managing received messages, and notifying the first thread when a client disconnected.

Anyhow, let me know if you have further questions.

bryanhdl · 01-16-2008, 01:30 PM

Hi,

On my server-like program, there is one thread for select(), FD_ISSET() and recv() in a loop of two steam sockets, the other thread handles conection call control.

The rfds_save is never changed which always has fdA and fdB.
My problem is when there are two connections, FD_ISSET() in receive thread detects only fdA and does not detect fdB.

Do you know how to assign fdA or fdB to accept different connections?

Thank you.

dwhitney67 · 01-16-2008, 02:34 PM

I'm sorry, I don't quite understand the question.

A server has an open port, which is managed by a socket descriptor. It uses select() to determine if there is activity on that socket (i.e. if a client is connecting). If there is activity on the socket, then the server accepts the client connection. Here's the code for the "listener" thread:

PHP Code:



    //  Listener thread loop
    //
    while (!stop_requested())
    {
      fd_set         listen_set;
      struct timeval timeout = {1,0};

      FD_ZERO(&listen_set);
      FD_SET(m_listen_socket, &listen_set);


      //  Determine if anyone is attempting to connect to the listen socket.
      //  If not, then continue; else accept the connection.
      //
      if (select(m_listen_socket+1, &listen_set, NULL, NULL, &timeout) == 0)
        continue;

      if (!(FD_ISSET(m_listen_socket, &listen_set)))
        continue;


      //   Accept connection (loop back on error)
      //
      int sock_len = sizeof(sock);
      int fd       = -1;

      if ((fd = accept(m_listen_socket, (struct sockaddr *) &sock, &sock_len)) < 0)
      {
        if (errno != EWOULDBLOCK)
        {
          const int err = errno;
          dbg[*this] << "Accept Failed (" << err << ")." << el;
        }
        continue;
      }

      dbg[*this] << "Connection Accepted, client fd = " << fd << el;

      accept_connection(fd);
    }

The accept_connection() method creates a new client object with the unique file-descriptor 'fd' for that client. The next client that connects would have a different file-descriptor.

The receiver portion of the server, which is another thread, uses select() that monitors each of the file-descriptors assigned to connected clients. When select() reports activity, the returned fd_set is passed to the object serving as the listener-thread; this thread then reports which client sent data. Only then does the receiver thread get a handle to the client object. Here's how I did that:

PHP Code:



  //  Receiver thread loop
  while (!stop_requested())
  {
    //   Setup file descriptor list for select call
    //
    struct timeval timeout = {1, 0};  // one second
    fd_set         read_set;
    const uint     nfds = m_debug_listen.get_client_set(read_set);


    //   Check if there is any data traffic to be read on any of the
    //   file descriptors.
    //
    if (select(nfds+1, &read_set, NULL, NULL, &timeout) == 0)
    {
      dbg[*this] << "select timed out" << el;
      continue;
    }


    dbg[*this] << "Detected Activity" << el;


    //   Activity detected... find out if its from one of the clients
    //   we are monitoring.  Record any clients that send us bad data or
    //   that disconnect.
    //
    TDD_debug_client *client = m_debug_listen.get_debug_client(read_set);

    if (client == NULL)
    {
      dbg[*this] << "Client object could not be found" << el;
      continue;
    }

    // Now that the client handle is available, attempt to read data
    // from it.  Remove the client if it has disconnected.
    // ...
  }

I'm certain that there are other ways to model the server application, so please don't feel your design is deficient if it differs from mine. I was very new (and still am) to socket programming when I wrote this code long ago.

bryanhdl · 01-16-2008, 04:25 PM

Thank you for the code. Do you call FD_SET(fd, &listen_set) in accept_connection(fd)?

dwhitney67 · 01-16-2008, 05:08 PM

No I do not. However, that is not to say you can't.

My accept_connection() method merely creates a new client object, using the socket descriptor for that client.

I implemented a separate method in my 'listener' thread to perform the FD_SET (looping through my list of clients). When done, this method returns both the fd_set value and the max-FD (or 'nfds') to the caller (i.e. the thread waiting for activity from clients). These values are then used within the select().

Here's that code again from the receiver thread:

PHP Code:



fd_set read_set; 
const uint nfds = m_debug_listen.get_client_set(read_set); 
 
//   Check if there is any data traffic to be read on any of the 
//   file descriptors. 
// 
if (select(nfds+1, &read_set, NULL, NULL, &timeout) == 0) 
...

I suppose you could do the FD_SET in your "accept connection" method, but eventually you will still require to know the highest-numbered socket descriptor for use in the select() call.

bryanhdl · 01-18-2008, 12:02 AM

Is the listener thread applied to udp sockets?

Thanks.

dwhitney67 · 01-18-2008, 01:33 AM

In the code I wrote, I was using TCP.

dwhitney67 · 01-18-2008, 01:45 AM

Btw, your little exercise piqued my interest in revamping my skills with socket programming. Below are the listings of my Listener and Receiver threads, followed by the Client Manager -- all written in C++ and relying on the Boost libraries. This was hastily thrown together yesterday, so it may not be the best design. In fact, it probably would be nice to have a separate Receiver thread for each client, rather than one to service them all.

Listener.cpp:

PHP Code:



#include "Listener.h"
#include "Client.h"
#include "ClientMgr.h"

#include <netinet/in.h>
#include <cstring>        // for memset()
#include <cerrno>         // for errno
#include <iostream>       // for cerr, endl


// Constructor
// (I) port       - port number to listen for client connections.
// (I) maxClients - max number of clients that may connect.
// (I) clientMgr  - object for managing list of connected clients
//
Listener::Listener( const int port, const int maxClients, ClientMgr &clientMgr )
  : m_port( port ),
    m_maxClients( maxClients ),
    m_clientMgr( clientMgr )
{
  // do nothing here
}


// Destructor
//
Listener::~Listener()
{
  // do nothing here
}


// Thread main loop
//
void
Listener::operator()( void )
{
  struct sockaddr_in sock;

  initSocket( sock );

  while ( true )
  {
    fd_set listenSet;
    struct timeval timeout = { 1, 0 };

    FD_ZERO( &listenSet );
    FD_SET( m_listenSocket, &listenSet );

    if ( select( m_listenSocket + 1, &listenSet, 0, 0, &timeout ) == 0 )
      continue;

    if ( !FD_ISSET( m_listenSocket, &listenSet ) )
      continue;

    socklen_t sockLen = sizeof sock;
    int clientSD = -1;

    if ( (clientSD = accept( m_listenSocket, (struct sockaddr *) &sock, &sockLen )) < 0 )
    {
      if ( errno != EWOULDBLOCK )
      {
        std::cerr << "Listener: Accept Failed (" << errno << ")." << std::endl;
      }
      continue;
    }

    std::cout << "Listener: Adding client with sd = " << clientSD << std::endl;
    m_clientMgr.acceptConnection( clientSD );
  }
}


// Initialize socket.
// (I) sock - Socket Address Interface
//
void
Listener::initSocket( struct sockaddr_in &sock )
{
  memset( &sock, 0, sizeof sock );

  sock.sin_family      = AF_INET;
  sock.sin_addr.s_addr = htonl( INADDR_ANY );
  sock.sin_port        = htons( m_port );

  m_listenSocket = socket( sock.sin_family, SOCK_STREAM, 0 );

  bind( m_listenSocket, (struct sockaddr *) &sock, sizeof sock );

  listen( m_listenSocket, m_maxClients );
}

Receiver.cpp:

PHP Code:



#include "Receiver.h"
#include "Client.h"
#include "ClientMgr.h"

#include <netinet/in.h>
#include <sys/time.h>
#include <iostream>


// Constructor
// (I) clientMgr  - object for managing list of connected clients
//
Receiver::Receiver( ClientMgr &clientMgr )
  : m_clientMgr( clientMgr )
{
}


// Destructor
//
Receiver::~Receiver()
{
}


// Thread main loop
//
void
Receiver::operator()( void )
{
  while ( true )
  {
    struct timeval timeout = { 1, 0 };
    fd_set         readSet;
    const int      nfds = m_clientMgr.getClientSet( readSet );

    if ( select( nfds + 1, &readSet, 0, 0, &timeout ) == 0 )
    {
      // Timeout occurred
      continue;
    }

    // Detected activity
    Client *client = m_clientMgr.getClient( readSet );

    if ( client == 0 )
    {
      // could not find client object... error?
      continue;
    }

    bool newMsgAvailable = true;

    while ( newMsgAvailable )
    {
      char   msg[ 256 ] = { 0 };
      size_t msgSize = client->parseNextMsg( msg, sizeof msg );

      switch ( msgSize )
      {
        case Client::NO_NEW_MSG:
            newMsgAvailable = false;
            break;

        case Client::MSG_TOO_LARGE:
        case Client::CLIENT_DISCONNECTED:
            std::cout << "client disconnected" << std::endl;
            m_clientMgr.removeClient( client );
            newMsgAvailable = false;
            break;

        default:
            std::cout << "Message Received: " << msg;
            break;
      }
    }
  }
}

ClientMgr.cpp:

PHP Code:



#include "ClientMgr.h"
#include "Client.h"

#include <algorithm>   // for std::max()


// Constructor
// (I) port       - port number to listen for client connections.
// (I) maxClients - max number of clients that may connect.
//
ClientMgr::ClientMgr()
{
  // do nothing here
}


// Destructor
//
ClientMgr::~ClientMgr()
{
  // do nothing here
}


// Returns socket descriptor client set for clients that are connected
// (O) clientSet - socket descriptor set that is returned
//
// Returns the highest numbered socket descriptor of the connected clients.
//
int
ClientMgr::getClientSet( fd_set &clientSet )
{
  boost::mutex::scoped_lock lock( m_mutex );

  FD_ZERO( &clientSet );

  int nfds = 0;

  for ( Iterator it = m_clientList.begin(); it != m_clientList.end(); ++it )
  {
    FD_SET( it->first, &clientSet );

    nfds = std::max( nfds, it->first );
  }

  return nfds;
}


// Returns handle to client object
// (I) activeClient - socket descriptor set returned by select()
//
Client *
ClientMgr::getClient( const fd_set &activeClient )
{
  boost::mutex::scoped_lock lock( m_mutex );

  Client *client = 0;

  for ( Iterator it = m_clientList.begin(); it != m_clientList.end(); ++it )
  {
    if ( FD_ISSET( it->first, &activeClient ) )
    {
      client = it->second;
      break;
    }
  }

  return client;
}


// Remove a disconnected client from the list of clients
// (I) client - the client object
//
void
ClientMgr::removeClient( Client *client )
{
  boost::mutex::scoped_lock lock( m_mutex );

  Iterator it = m_clientList.begin();

  for ( ; it != m_clientList.end(); ++it )
  {
    if ( it->second == client )
    {
      close( it->first );
      delete it->second;
      m_clientList.erase( it );
      client = 0;
      break;
    }
  }
}


// Creates a new client object.
// (I) sd - socket descriptor assigned to connected client.
//
void
ClientMgr::acceptConnection( const int sd )
{
  boost::mutex::scoped_lock lock( m_mutex );

  if ( m_clientList.find( sd ) == m_clientList.end() )
  {
    m_clientList[ sd ] = new Client( sd );
  }
}