Synchronous vs. Asynchronous, Blocking vs. Non-Blocking I/O

#include <sys/socket.h>
#include <fcntl.h>
...

int main(int argc, char **argv)
{
	...

	// 1. load up local address info
	getaddrinfo(NULL, MYPORT, &hints, &servinfo);

	...

	// 2. bind to the socket
	sockfd = socket(servinfo->ai_family, servinfo->ai_socktype, servinfo->ai_protocol);
	fcntl(sockfd, F_SETFL, O_NONBLOCK);

	...

	// 3. recv
	while( (numbytes = recvfrom(sockfd, buf, MAXBUFLEN - 1, 0, (struct sockaddr *)&client_addr, &addr_len)) == -1);

	...

	return 0;
}

/* 
 * selectserver.c - multiperson chat server using select
 * usage - telnet localhost 9034
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define PORT "9034" // port we're listening on

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
	if (sa->sa_family == AF_INET)
	{
		return &(((struct sockaddr_in *)sa)->sin_addr);
	}

	return &(((struct sockaddr_in6 *)sa)->sin6_addr);
}

int main(int argc, char **argv)
{
	// !!! in this case, we assume all the function call is success and we discard all the error checking codes !!!

	fd_set global;   // global file descriptors set
	fd_set read_fds; // read file descriptors set for select()
	int fd_max;		 // maximum file descriptor number
	int server;							 // server socket fd
	int new_fd;							 // file descriptor for newly connected sockets
	struct sockaddr_storage client_addr; // client address
	socklen_t addrlen;
	char buf[256];
	int nbytes;
	char client_ip[INET6_ADDRSTRLEN];
	struct addrinfo hints, *res;

	// 1. load local address info
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE; // flags for local
	getaddrinfo(NULL, PORT, &hints, &res);

	// 2. bind to socket & listen
	server = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
	bind(server, res->ai_addr, res->ai_addrlen);
	listen(server, 10);
	freeaddrinfo(res);

	// 3. add server fd to global fd set
	FD_ZERO(&global);
	FD_ZERO(&read_fds);
	FD_SET(server, &global);
	fd_max = server;

	// 4. use select for message handling
	while (1)
	{
		read_fds = global; // select on all the fds
		select(fd_max + 1, &read_fds, NULL, NULL, NULL); // fd_max + 1 to present the count
		for (int i = 0; i <= fd_max; ++i)
		{
			if (FD_ISSET(i, &read_fds)) // got a readable fd
			{
				if (i == server) // server handling
				{
					// new connections
					addrlen = sizeof client_addr;
					new_fd = accept(server, (struct sockaddr *)&client_addr, &addrlen); // new socket fd, discard error handling here

					FD_SET(new_fd, &global);
					if (new_fd > fd_max)
					{
						fd_max = new_fd;
					}
					printf("selectserver: new connection from %s on socket %d\n",
						   inet_ntop(client_addr.ss_family,
									 get_in_addr((struct sockaddr *)&client_addr),
									 client_ip, INET6_ADDRSTRLEN),
						   new_fd);
				}
				else // client message handling
				{
					nbytes = recv(i, buf, sizeof buf, 0);

					if (0 == nbytes) // closed connection
					{
						printf("selectserver: socket %d hung up\n", i);
						// close fd locally
						close(i);
						FD_CLR(i, &global);
					}
					else // got a new message
					{
						// send to every one
						for (int j = 0; j <= fd_max; ++j)
						{
							if (FD_ISSET(j, &global) && j != server && j != i) // this client socket is connected to the server
							{
								send(j, buf, nbytes, 0);
							}
						}
					}
				}
			}
		}
	}
	return 0;
}