3

I'm writing a C network server that will pair two clients together and allow them to send messages to each other.

At the moment, each client has their own thread in the server and in the thread I have a loop that is basically while((numBytesRead = read(fd, buffer, 1024)) > 0). This works fine and I am able to receive messages and then echo them back to the client.

My problem is though that I'm not sure the best way of transferring a message from one client to another through the server.

I think my biggest issue is that read() blocks, so I won't be able to send a message to a client until the client sends some text to the server so that read stops blocking.

Is there any way around this? My initial thought was to make one thread for reading from the client and one for writing to the client but if read is blocking in one thread and then I try to write to the same file descriptor then won't this cause issues?

Appreciate any help!! :)

JimR
  • 2,145
  • 8
  • 28
  • 37
  • 1
    related: http://stackoverflow.com/questions/4675824/how-to-implement-a-full-duplex-channel-over-tcp-with-a-single-thread – cmcginty May 30 '11 at 07:28

3 Answers3

2

read only blocks the thread of the client that isn't sending data; so you can in theory use the thread of the client that just sent data to write to the other.

An alternative may be to make the client sockets be non-blocking, which causes the read to return immediately (with error) if there is no data in the stream. However this is very processor-intensive as both sockets are continually being probed for data and (almost always) returning with none.

My final suggestion for places to look is at the select function, which can be used to check a set of file descriptors and block until any of them have data in the stream; and additionally it can be passed a timeout (an upper limit for how long to block). A rough sketch of an algorithm might be:

  1. select( client-sockets, 100ms )
  2. for each socket with available data:
    1. read the data
    2. store it in the other socket's output-buffer
  3. for each socket:
    1. write its current output buffer
  4. repeat
Matty K
  • 3,781
  • 2
  • 22
  • 19
  • Thanks Matty!! I'm interested in the first solution but I'm a bit worried about trying to `write` to a file descriptor in one thread while another thread is trying to `read` from it? Is this safe to do? – JimR May 30 '11 at 07:42
  • @Sam It should be perfectly fine. Please let me know if it's not. – Matty K May 30 '11 at 07:47
  • Thanks, I ended up making a write thread and a read thread.. seems to work really well. :) – JimR May 30 '11 at 09:47
1

this is certainly not a simple question

  1. design a protocol and protocol message format
  2. read protocol message from socket
  3. deal with message with type of "login"
  4. bind an uniq id to this socket
  5. read other messages of type "message" from socket(sender), which contain a "receiver id"
  6. find a socket with that id(receiver)
  7. send the data in the message to receiver

suggest using IO multiplex instead of multi threaded.

ideawu
  • 2,287
  • 1
  • 23
  • 28
0

Using non-blockin operation is good choice for server design. In this case the simplest way is using select or poll. More advanced is kqueue (FreeBSD) и epoll (Linux), also asynchronous I/O (AIO) could be used

So if select() is the choice, the next approach could be used (just example, something like pseudo code):

fd_set read_set, write_set;
struct timeval timeout;

while(!quit)
{
     // adds your sockets to fd_set structure, return max socket + 1, this is important! 
     max = fillFDSet(&read_set); 
     setReadTimeout(&timeout); // sets timeout for select

     if (0 < select(max, &read_set, NULL, NULL, &timeout)) // wait for read
     {
           // there is at least one descriptor ready
           if (FD_ISSET(your_socket))
           {
               socket_size = read(socket, socket_buffer, 1024);
           }
     }
     max = fillFDSet(&write_set); 
     setWriteTimeout(&timeout); // sets timeout for select

     if (0 < select(max, NULL, &write_set, NULL, &timeout)) // wait for write
     {
           // there is at least one descriptor ready
           if (FD_ISSET(your_socket))
           {
               write(socket, socket_buffer, socket_size);
           }
     }
}
tvn
  • 634
  • 3
  • 6