what is the backlog in the int listen (SOCKET s, int backlog); function good for

When you create a socket, and put it to listen, you need to specify the amount of connection you want to handle. I believe Linux refuses new connections.

Yep

No, it sets the socket in listen mode. You then call accept to get incoming calls. Usually, you do a while like:

    listen(oldsocket, 32);
    while ((newsocket = accept(oldsocket, ...)) > 0) {
        process_new_client(newsocket);
        ...
    }

That piece of code is blocking

listen returns immediately. accept is the one which blocks the socket until a client connects. You can use fnctl (Linux for sure... maybe Windows has it too?) to declare the socket as non blocking, or use select to simulate the non-blocking stuff.

Yes, you can use select to multiplex a program. Select has five parameters, the first one is the maximun descriptor plus one of socket to check, the second parameter is a bag (fd_set) with sockets to check for incoming information (receive data), the third parameter is a bag for outcoming information (send data), the fourth is a bag with sockets for exceptions, and the last parameter is the timeout select should wait before stopping checking the sockets. So, you can set sockets to listen into the second bag, and whenever one is set, you receive the information. This is the example in Linux:

(Edited: In FD_SET(0, &rfds); he sets socket 0 (stdin) in the bag for sockets to listen. Then calls select with 1 as first parameter (highest descriptor in all bags, in this case 0, plus one). tv holds how long select will wait for connections. Here is set for five seconds, so the program will block for 5 seconds in select. If you set 0, it becomes non-blocking.)

The only way I remember to make recv non blocking is using fcntl. With select, you peek the socket, if it has something, you call recv (which is still blocking, but since you know there is something to read, it returns immediately. If you need some code example from me, you need to wait until I go back home

backlog is NOT the number of clients you may have connected! The backlog parameter refers to the number of clients that are waiting for you to call accept. If you call listen with backlog 16, and before you call accept 17 people try to connect, 16 people will make it through, and 1 will be refused. When you call accept once, there will be 15 people pending. If 2 people try to connect then before the next accept call, one will be refused. So on and so forth. It is the number of pending connections waiting to be accepted before they are completely rejected.

hmm so if i want to accept 32 clients then i have to set the backlog at least to 32 but better very high for there is the chance for as much as possible clients to wait (in a qeue) for my acception?

Ok, here is a very small program. Put this into a file and add it to a VC project, add Ws2_32.lib library for linking, and compile it. Under MinGW, use g++ main.cpp -o main.exe -lwsock32. Execute it. By default, it is a non blocking program. There is a number counting advancing to show you it is not blocking the execution.

Now, run a telnet (telnet localhost 4344). Telnet will connect, and everytime you type something, it will send the letter to the server. You can connect up to 32 telnets. Every time you type a letter, the server prints the socket and the letter. If you see the Task Manager, the program would be taking like 99% of CPU.

If you want your server to wait for 1 second before continuing processing, pass 1 as argument. You will notice I set the new delay. This time, the server will wait for 1 second before continuing with the program. Finally, if you want to make the program blocking, pass -1 as argument. If you check the code, I call select with NULL as last parameter to block it.

Be careful! I am not doing error handling when a telnet shuts down, so if you do it will get mad I hope the example is good enough.

(Edited: Non-Windows support is not tested, too sleepy to turn my other computer on, but should work with one or two hacks).

Could it be that TCP/IP limits it to 5, and so anytime using *_INET family it is limited to 5?

If you don't need features present only in 2.0 you don't really have a reason to use it...

Yes. It's likely that everything you need is in 1.1, and that will also ensure portability as you will mostly be using BSD socket functions, which are easily ported to any *nix platform later.