Need implementation advice , using threading and sockets

I am programming a internet chat program.

I am not sure how to implement "multiple chat rooms with multiple users". I have a few ideas but I'm not sure what is the best solution or proper way to do this, as I am a low-medium level C/Socket programmer. This is a simple project for learning, I don't want to try to implement thread pools or something complicated for now.

First implementation idea is to have multiple sockets listening on different ports OR should it be one socket listening on multiple ports?

- each group of clients will have their own port (or chat room)

- In my server driver , I will run/create a thread for each of those sockets? so that they can sit in a while loop and wait for client connections to accept()

- Then each socket thread will create a thread for each client connection? so that they can send back the chat room messages.

Ive quickly typed up some code, but I don't want to continue with this approach unless its correct...

Code:

---

server_drive.c

int ports[3] = {3000,5000,8000};

for(int i=0; i < 3; i++){

  chat_room_sockets[i] =  new_chat_room_socket(ports[i]);
 
  pthread_t thread;
  int* sock = malloc(sizeof(int));
  *sock = chat_room_sockets[i];
  pthread_create(&thread,NULL, start_chat_room, sock);
  pthread_detatch(thread);
}

..

---

Code:

---

server_interface.h

int new_chat_room_socket(int port){
    int server_sock;
    struct sockaddr_in server_address;


    if((server_sock = socket(PF_INET, SOCK_STREAM,  IPPROTO_TCP)) < 0){
    return -1;
    }


    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(port);


    if (bind(server_sock, (struct sockaddr *)&server_address, sizeof(server_address)) < 0){
    return -1;
    }
   
    if (listen(server_sock, MAXPENDING) < 0){
    return -1;
    }
 
 return server_sock;
}




void* start_chat_room(void* sock){
 
  int client_sock;
  struct sockaddr_in client_address;
  int client_length = sizeof(client_address);

  for(;;){
      if((client_sock = accept((int)sock , (struct sockaddr*) &client_address , &client_length )) < 0){
   
    //add_chat_user(client_sock);
  }
}

 
..

---

TBH, I would suggest ditch threads and study the select() system call.
With select(), you can monitor all your live sockets for activity, then decide what to do with each one.
select() even has a timeout, so there's no need to worry about blocking yourself.

You have a single port you listen() on for incoming connections.

Each accept() generates a new socket, which you can associate with a user+room.

Your select() loop can tell you which sockets are ready to be processed.

Perhaps maintain a separate list of each room, and all the sockets connected to that room.

Quote:

---

Originally Posted by Salem

TBH, I would suggest ditch threads and study the select() system call.
With select(), you can monitor all your live sockets for activity, then decide what to do with each one.
select() even has a timeout, so there's no need to worry about blocking yourself.

You have a single port you listen() on for incoming connections.

Each accept() generates a new socket, which you can associate with a user+room.

Your select() loop can tell you which sockets are ready to be processed.

Perhaps maintain a separate list of each room, and all the sockets connected to that room.

---

okay let me make sure I'm understanding this correctly,

one socket listens for users trying to connect to server?
when it gets a new accept() it saves the client socket?

I originally thought of this but wasn't sure enough at the time how to setup the "chat rooms"

edit: so I just implemented this method it seems to work.

I will just setup a bash script or something to start multiple processes of the program.
each program will server on a different port , each process will represent the chat room instead.

There is only ever one port per socket.

Client-Server Background
Except for the fork stuff,

Essentially,

Code:

---

sockfd = socket();  // for your listening port
bind(sockfd)
listen(sockfd);
fd_set masterSet;
FD_ZERO(&masterSet);
FD_SET(sockfd,&masterSet);
int maxFd = sockFd;
while ( 1 ) {
    fd_set working = masterSet;
    int res = select(maxFd+1,&working,NULL,NULL,NULL);  // wait forever until something happens
    if ( res > 0 ) {
        for ( int i = 0 ; i < maxFd ; i++ ) {
            if ( FD_ISSET(i,&working) ) {
                if ( i == sockfd ) {
                    newFd = accept();
                    FD_SET(newFd,&masterSet);  // add this to the things to be watched.
                    // calculate a new maxFd;
                } else {
                    // it's one of your client connections.
                    // Forward message onto all other clients for the same room.

                    // If that connection comes back as closed, then you need to do
                    FD_CLR(i,&masterSet);
                    // calculate a new maxFd;
                }
            }
        }
    }
}

---

Quote:

---

Originally Posted by Salem

There is only ever one port per socket.

---

Okay, I must have misread the SO post I learned this from.



Reviewing Code:

I think I understand most of this for now,

we use select to monitor all input coming from all chat rooms? and also incoming connections?
masterset will hold all the file descriptors?
so then I should also find a way to group the client file descriptors for each room?


not understanding maxFd = sockFd
why would we want to set this to sockFd ?


not really understanding the for loop i to maxFd
why this range?
why compare i to sockFd , why would i == sockFd mean we should wait for another accept()

This is good start: Beej's Network Guide

> we use select to monitor all input coming from all chat rooms? and also incoming connections?
Yes.

> masterset will hold all the file descriptors?
Yes, because select() modifies the set, so you need an original one and a copy for the current select() call.

> so then I should also find a way to group the client file descriptors for each room?
Yes, you'll need an additional data structure to contain this information.
Perhaps the first message on each connection is the room the client wants to join.

> not understanding maxFd = sockFd
> why would we want to set this to sockFd ?
Because select() needs to know what the maxFd in the set is (for efficiency I guess).
And because in an otherwise empty set with only one fd in it, the maxFd is obviously the fd just added.

> not really understanding the for loop i to maxFd
Well if you have 10 Fd's in the set, and only two of them have anything to report, you need to find them in some way.

> why this range?
Because.... efficiency.
You could scan all 1024 (or whatever FD_SETSIZE is on your machine), but that's wasteful.

> why compare i to sockFd , why would i == sockFd mean we should wait for another accept()
There is no wait for another accept, an accept is ready to happen now.


> as I am a low-medium level C/Socket programmer.
I thought you knew all this stuff.

sorry this was old , I figured out the answer to everything and understand this simple example a lot more now.
I wasn't following along with the select macros very well at first.

... I think the tricky part is grouping subsets of the master set to create "chat rooms"

one idea is to just run multiple processes of this program with a port specified, and then each process is a chat room.

but I like the idea better of a user connecting to this server through the main listening port and then chooses a port, which will be his chat room. but that seems like the tricky part.


or maybe just create an fd_set for chat rooms , when I receive a message from an fd just broadcast that message back to all the fd's in the fd_set that the fd belongs to.

I guess it depends on how much interaction there is between threads.

If the answer is none, then it shouldn't be too difficult.

But if the answer is some, then you NEED a good design - seriously!.

Because a random hackery rats-nests of randomly applied mutexes to fix whatever race conditions you've managed to create for yourself will just do your head in.

If debugging the hardest single-threaded program rates as 10, then debugging the hardest multi-threaded program rates about 1000.
Heisenbug - Wikipedia

haha , thanks a lot for your help. I think threads could be a headache but Im still willing to at least learn a threaded implementation because its good for knowledge.


But obviously select() makes things a lot easier. thanks for introducing this.


For now I think I will try the approach

having a set of listening sockets (for each port)

then for each socket have a fd_set of client sockets

so if i == that socket (I get a new connection) I will accept() the new fd and add it to its respective set.

... or something similar to this approach