如何将一些数据从服务器写入连接到我的服务器的所有客户端？

Question

I have a small problem and I don't find any solutions. I have this code.

Server code

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>

#define PORT 2908
extern int errno;

typedef struct thData{
    int idThread; 
    int cl; 
}thData;

static void *treat(void *); 
void raspunde(void *);

int main ()
{
  struct sockaddr_in server;    
  struct sockaddr_in from;  
  int nr;       
  int sd;       
  int pid;
  pthread_t th[100];
    int i=0;



  if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
    {

      return errno;
    }
  int on=1;
  setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));

  bzero (&server, sizeof (server));
  bzero (&from, sizeof (from));

    server.sin_family = AF_INET;    
    server.sin_addr.s_addr = htonl (INADDR_ANY);
    server.sin_port = htons (PORT);

  /
  if (bind (sd, (struct sockaddr *) &server, sizeof (struct sockaddr)) == -1)
    {

      return errno;
    }


  if (listen (sd, 2) == -1)
    {
      perror ("[server]Error at listen().\n");
      return errno;
    }

  while (1)
    {
      int client;
      thData * td;     
      int length = sizeof (from);


      fflush (stdout);


      if ( (client = accept (sd, (struct sockaddr *) &from, &length)) < 0)
    {
      perror ("[server]Error at accept().\n");
      continue;
    }

    td=(struct thData*)malloc(sizeof(struct thData));   
    td->idThread=i++;
    td->cl=client;

    pthread_create(&th[i], NULL, &treat, td);         

    }//while    
};              
static void *treat(void * arg)
{       
        struct thData tdL; 
        tdL= *((struct thData*)arg);    
        printf ("[thread]- %d - Waiting the message...\n", tdL.idThread);
        fflush (stdout);         
        pthread_detach(pthread_self());     
        raspunde((struct thData*)arg);
        close ((intptr_t)arg);
        return(NULL);   

};


void raspunde(void *arg)
{
        int nr, i=0;
    struct thData tdL; 
    tdL= *((struct thData*)arg);
    if (read (tdL.cl, &nr,sizeof(int)) <= 0)
            {
              printf("[Thread %d]\n",tdL.idThread);
              perror ("Error at read() from client.\n");

            }

    printf ("[Thread %d]The message is...%d\n",tdL.idThread, nr);


              nr++;      
    printf("[Thread %d]Sending the message back...%d\n",tdL.idThread, nr);

        printf("%d\n",tdL.cl );
     if (write (tdL.cl, &nr, sizeof(int)) <= 0)
        {
         printf("[Thread %d] ",tdL.idThread);
         perror ("[Thread]Error at write() from client.\n");
        }
    else
        printf ("[Thread %d]The message was sent.\n",tdL.idThread); 

}

The above code is a server that creates for every client a thread. The client sends a number to the server and the server will answer back to the client with the number incremented by 1.

The question is how can I write for example the nr from the response function or a string message to all my clients that are connected on my server?

Thank you in advance!

Answer 1

As pointed out in the comments, you'll have to keep a list of active threads (protected by a mutex!) to know who is connected to your server. When a thread is created it would be added to the list and when execution finishes it would remove itself. So you sould make the following changes:

1. Create a global list of threads and a pthread_mutex_t to protect it (this would happen in main)
2. Create a function to insert a thread to the list and a function to remove threads. Don't forget to take the mutex before modifying the list and release it after.
3. Add the insert in the treat function as the first instruction and the add the remove function before close (to prevent sending to a closed connection)
4. Define a broadcast function that takes a message, loops through the global list and sends the message to each client. Again don't forget to take the mutex while looping through the list and release it when done. You might also want to take into consideration skipping the sender of the broadcast.

The simplest way to implement this would be to use a singly linked list where you always insert at the head (to keep insertion fast) and remove items by their id. The function headers should look like this:

// your linked list
list_t* threadList;
pthread_mutex_t mutex;

void insert_list(thData* th);

// This could also return void, since to know the id you must already have the data that will be returned
thData* remove_list(int id);

// msg can have any type
void broadcast(int msg, int broadcasterId);