Socket Client/Server Chat (Threads Problems) - c

Question

I have a problem with the implementation of a client/server chat.
The problem is that I can not handle the connection with two (or more) clients at the same time. In fact the server responds only to one client and not to all.
The server code is more less like this:
/*include*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <string.h>
#include <signal.h>
#include <pthread.h>
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>
/*define*/
#define PORT 5050
#define MSG_SIZE 100
#define NUM_UTENTI 5
//the thread function
void *fun_receiver(void *);
void *sender2(void *);
/*////////////////////// MAIN FUNCTION /////////////////////////////*/
int main(){
int serverfd , clientfd, c, *new_client;
struct sockaddr_in server_addr , client_addr;
//Create socket
serverfd = socket(AF_INET , SOCK_STREAM , 0);
//Prepare the sockaddr_in structure
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons( PORT );
//Bind
bind(serverfd,(struct sockaddr *)&server_addr , sizeof(server_addr));
puts("bind done");
//Listen
listen(serverfd , 5);
//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
//thread_id
int t=0;
pthread_t thread_receiver;
pthread_t thread_invio;
while(true){
clientfd = accept(serverfd, (struct sockaddr *)&client_addr, (socklen_t*)&c);
if (clientfd < 0){
perror("accept failed");
return 1;}
new_client=malloc(sizeof(int));
*new_client=clientfd;
if( pthread_create( &thread_receiver , NULL , fun_receiver , (void*) new_client) < 0){
perror("could not create thread");
return 1;
}
if( pthread_create( &thread_invio , NULL , sender2 , (void*) new_client) < 0){
perror("could not create thread");
return 1;
}
}//end while
close(serverfd);
return 0;
} //fine main
//////sender
void *sender2(void *clientfd)
{
int sock = *(int*)clientfd;
char buf[30];
while(true){
bzero(&buf, 30 * sizeof(char));
printf("Inserisci Messaggio3: ");
gets(buf);
int len, byte_sent;
len=strlen(buf);
byte_sent = send(sock, buf, len, 0);
}
return 0;
}
////receiver
void *fun_receivervoid *serverfd)
{
int sock = *(int*)serverfd;
char msg[MSG_SIZE];
bzero(&msg, MSG_SIZE * sizeof(char));
int read_size;
int count = 0;
while( (read_size=recv(sock, msg, MSG_SIZE * sizeof(char), 0)) > 0 ){
/*if(strcmp(msg, exit)==0){
printf("Arrivederci!\n");
close(sock);
}*/
printf("%s\n", msg);
bzero(&msg, MSG_SIZE * sizeof(char));
}
return 0;
}
the same code is in the client side after the connect(): there are two threads one for sending messages (to the server) and one for receiving messages (from the server). Both threads relies on the same client socket.
What happens:
The client1 connects to the server (writes and receives messages to/from the server) / / all ok!
The client2 connects to the server (writes messages to the server but doesn't receive anything..)
The problem is that if the server writes a message only client1 receives while client2 doesn't.
How is this possible? where I am wrong? I would like that server could send messages to all the clients not only one!

Answer 1

Your code can be improved in many ways. But I feel currently the critical problem here is in the
*new_client=clientfd;
The pointer (new_client) is not even initialized. And more over you want to use the value stored, in multiple threads.
In that case you need to have different memory areas, so that individual threads get the correct value of connection descriptor.
I would suggest to write
new_client = malloc(sizeof(int));
*new_client=clientfd;
Now individual threads will get the correct connection descriptor. I hope this will solve the problem.