Communication over sockets involves 2 programs running on the same machine or on separate machines across a network.

First is a socket server and the other is a socket client. Tcp stands for Transmission control protocol and it is the most common protocol being used for most of the network communication that takes place over internet or a lan.

There are other important protocols like udp, arp, icmp and they are used mandatorily but in small quantities.

These protocols are technically speaking, define the format how data should be structured into packets when sending them across a network.

So every protocol has a different format and most importantly has a different purpose.

For example for all kinds of content download and upload, tcp is used. For network analysis the icmp and arp protocols are used and so on. Every protocol has been designed to serve a different purpose.

So in this post we shall see how to write a socket server on windows using the winsock api. Winsock is the socket api on windows and can be used to write socket speaking applications. The code shall be in C.

So a socket server is an application that runs on a machine and expects clients to connect to it so that it can serve them.

The steps to write a socket server are simple.

1. Create a socket. 2. Bind it to an ip and port. 3. Start listening on it 4. Accept incoming connections and process them.

Each of the above steps has an associated function as we shall soon see in the code.

Server Code

/* Bind socket to port 8888 on localhost */ #include<io.h> #include<stdio.h> #include<winsock2.h> #pragma comment(lib,"ws2_32.lib") //Winsock Library int main(int argc , char *argv[]) { WSADATA wsa; SOCKET s , new_socket; struct sockaddr_in server , client; int c; char *message; printf("

Initialising Winsock..."); if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) { printf("Failed. Error Code : %d",WSAGetLastError()); return 1; } printf("Initialised.

"); //Create a socket if((s = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET) { printf("Could not create socket : %d" , WSAGetLastError()); } printf("Socket created.

"); //Prepare the sockaddr_in structure server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons( 8888 ); //Bind if( bind(s ,(struct sockaddr *)&server , sizeof(server)) == SOCKET_ERROR) { printf("Bind failed with error code : %d" , WSAGetLastError()); } puts("Bind done"); //Listen to incoming connections listen(s , 3); //Accept and incoming connection puts("Waiting for incoming connections..."); c = sizeof(struct sockaddr_in); new_socket = accept(s , (struct sockaddr *)&client, &c); if (new_socket == INVALID_SOCKET) { printf("accept failed with error code : %d" , WSAGetLastError()); } puts("Connection accepted"); //Reply to client message = "Hello Client , I have received your connection. But I have to go now, bye

"; send(new_socket , message , strlen(message) , 0); getchar(); closesocket(s); WSACleanup(); return 0; }

The above code will start a socket server on port 8888. Run it from one console and then in another console connect to it using the telnet command. The output of the telnet should look like this

Hello Client , I have received your connection. But I have to go now, bye

The server sends this message to the connected client. The server is built using the following important functions

1. socket - create a socket 2. bind - bind the socket to a local address and port 3. listen - make the socket listen to incoming connections. 4. accept - accept any incoming connections.

The accept function returns a new socket which indicates the connection between this program and the remote client program. The master socket can continue to receive the next connections. The above program demonstrates how a socket program can work, but it is very limited in its functionality. It can just accept 1 incoming connection and after that it is dead.

Handle multiple connections - Asynchronous socket programming

For this server to be any useful, it must be able to accept multiple incoming connections and keep processing them till the clients want. So the next attempt shall be to write a server that can handle multiple connections and tackle all of them simultaneously.

There are many ways to handle multiple client connections. The first and most intuitive one is using threads. As soon as a client connects, assign a separate thread to process each client. However threads are too much work and difficult to code properly.

There are other techniques like polling. Polling involves monitoring multiple sockets to see if "something" happened on any of them. For example, the server could be monitoring the sockets of 5 connected clients, and as soon as any of them send a message, the server gets notified of the event and then processes it. In this way it can handle multiple sockets. The winsock api provides a function called "select" which can monitor multiple sockets for some activity.

Since we are able to handle all sockets together at once it is called asynchronous socket programming. It is also called event-driven socket programming or select()-based multiplexing.

The select function prototype is like this

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout);

The first parameter is a dummy one. The readfds parameter is a pointer to an array of sockets which should be monitored to be readable. This means that if any socket in the readfds set receives some data, it becomes readable. Similarly the writefds sockets would be monitored to be writable and the exceptfds sockets shall be monitored for any error. The last parameter is the timeout parameter, which indicates the length of time which the select function shall wait for before returning.

Now after a select function returns, it re-fills the same readfds array with the readable sockets. Same with writefds and exceptfds. This means that we have to keep calling select function in a loop, and everytime have to prepare our list of readfds, writefds and exceptfds array of sockets to pass.

The socket arrays are variables of type fd_set. fd_set is basically a structure that looks like this

typedef struct fd_set { u_int fd_count; SOCKET fd_array[FD_SETSIZE]; } fd_set;

To work with fd_set array the following macros have to be used.

FD_CLR(s, *set) - Removes a socket from an fd_set structure FD_ISSET(s, *set) - Checks if a socket is present in an fd_set structure FD_SET(s, *set) - Adds a socket to an fd_set structure FD_ZERO(*set) - Initializes the set to the null set. This will empty an fd_set structure

Now that is a lot of theory. Lets get to the final code that uses all that theory to get something working.

/* TCP Echo server example in winsock Live Server on port 8888 */ #include<stdio.h> #include<winsock2.h> #pragma comment(lib, "ws2_32.lib") //Winsock Library int main(int argc , char *argv[]) { WSADATA wsa; SOCKET master , new_socket , client_socket[30] , s; struct sockaddr_in server, address; int max_clients = 30 , activity, addrlen, i, valread; char *message = "ECHO Daemon v1.0 \r

"; //size of our receive buffer, this is string length. int MAXRECV = 1024; //set of socket descriptors fd_set readfds; //1 extra for null character, string termination char *buffer; buffer = (char*) malloc((MAXRECV + 1) * sizeof(char)); for(i = 0 ; i < 30;i++) { client_socket[i] = 0; } printf("

Initialising Winsock..."); if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) { printf("Failed. Error Code : %d",WSAGetLastError()); exit(EXIT_FAILURE); } printf("Initialised.

"); //Create a socket if((master = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET) { printf("Could not create socket : %d" , WSAGetLastError()); exit(EXIT_FAILURE); } printf("Socket created.

"); //Prepare the sockaddr_in structure server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons( 8888 ); //Bind if( bind(master ,(struct sockaddr *)&server , sizeof(server)) == SOCKET_ERROR) { printf("Bind failed with error code : %d" , WSAGetLastError()); exit(EXIT_FAILURE); } puts("Bind done"); //Listen to incoming connections listen(master , 3); //Accept and incoming connection puts("Waiting for incoming connections..."); addrlen = sizeof(struct sockaddr_in); while(TRUE) { //clear the socket fd set FD_ZERO(&readfds); //add master socket to fd set FD_SET(master, &readfds); //add child sockets to fd set for ( i = 0 ; i < max_clients ; i++) { s = client_socket[i]; if(s > 0) { FD_SET( s , &readfds); } } //wait for an activity on any of the sockets, timeout is NULL , so wait indefinitely activity = select( 0 , &readfds , NULL , NULL , NULL); if ( activity == SOCKET_ERROR ) { printf("select call failed with error code : %d" , WSAGetLastError()); exit(EXIT_FAILURE); } //If something happened on the master socket , then its an incoming connection if (FD_ISSET(master , &readfds)) { if ((new_socket = accept(master , (struct sockaddr *)&address, (int *)&addrlen))<0) { perror("accept"); exit(EXIT_FAILURE); } //inform user of socket number - used in send and receive commands printf("New connection , socket fd is %d , ip is : %s , port : %d

" , new_socket , inet_ntoa(address.sin_addr) , ntohs(address.sin_port)); //send new connection greeting message if( send(new_socket, message, strlen(message), 0) != strlen(message) ) { perror("send failed"); } puts("Welcome message sent successfully"); //add new socket to array of sockets for (i = 0; i < max_clients; i++) { if (client_socket[i] == 0) { client_socket[i] = new_socket; printf("Adding to list of sockets at index %d

" , i); break; } } } //else its some IO operation on some other socket :) for (i = 0; i < max_clients; i++) { s = client_socket[i]; //if client presend in read sockets if (FD_ISSET( s , &readfds)) { //get details of the client getpeername(s , (struct sockaddr*)&address , (int*)&addrlen); //Check if it was for closing , and also read the incoming message //recv does not place a null terminator at the end of the string (whilst printf %s assumes there is one). valread = recv( s , buffer, MAXRECV, 0); if( valread == SOCKET_ERROR) { int error_code = WSAGetLastError(); if(error_code == WSAECONNRESET) { //Somebody disconnected , get his details and print printf("Host disconnected unexpectedly , ip %s , port %d

" , inet_ntoa(address.sin_addr) , ntohs(address.sin_port)); //Close the socket and mark as 0 in list for reuse closesocket( s ); client_socket[i] = 0; } else { printf("recv failed with error code : %d" , error_code); } } if ( valread == 0) { //Somebody disconnected , get his details and print printf("Host disconnected , ip %s , port %d

" , inet_ntoa(address.sin_addr) , ntohs(address.sin_port)); //Close the socket and mark as 0 in list for reuse closesocket( s ); client_socket[i] = 0; } //Echo back the message that came in else { //add null character, if you want to use with printf/puts or other string handling functions buffer[valread] = '\0'; printf("%s:%d - %s

" , inet_ntoa(address.sin_addr) , ntohs(address.sin_port), buffer); send( s , buffer , valread , 0 ); } } } } closesocket(s); WSACleanup(); return 0; }

Does that look like a big program. Compile and run it. It should show an output like this

Initialising Winsock...Initialised. Socket created. Bind done Waiting for incoming connections...

Now the socket server is ready and waiting for incoming connection. At this point we need to connect to it using some client like telnet. But wait, we are not going to use telnet. Telnet has a problem that it always operates in character mode and that will screw up our interaction with this simple program. So get another utility called putty or ncat. Ncat is the netcat version that comes with nmap. Download it from their website. Or download puttytel , the putty telnet.

If you are using ncat then connect to the socket server like this

C:\>ncat localhost 8888

If you are using puttytel, the launch it and go to Connection > Telnet and select Passive mode. This will make putty line mode. Then come back to Session tab and enter the hostname and port and click open. it will connect to the server and start a black telnet like terminal.

Once the client program is connected with the server, try sending some message by typing first and then hit enter. The server will reply back with the same message.

C:\>ncat localhost 8888 ECHO Daemon v1.0 hello hello how are you how are you i am fine i am fine

The server terminal would look like this

Initialising Winsock...Initialised. Socket created. Bind done Waiting for incoming connections... New connection , socket fd is 3972 , ip is : 127.0.0.1 , port : 1129 Welcome message sent successfully Adding to list of sockets at index 0 127.0.0.1:1129 - hello 127.0.0.1:1129 - how are you 127.0.0.1:1129 - i am fine

And now, try to open multiple client terminals and connect at the same time to server. The server would be able to process requests from all the clients together.

Initialising Winsock...Initialised. Socket created. Bind done Waiting for incoming connections... New connection , socket fd is 3972 , ip is : 127.0.0.1 , port : 1129 Welcome message sent successfully Adding to list of sockets at index 0 127.0.0.1:1129 - hello 127.0.0.1:1129 - how are you 127.0.0.1:1129 - i am fine New connection , socket fd is 3956 , ip is : 127.0.0.1 , port : 1130 Welcome message sent successfully Adding to list of sockets at index 1 127.0.0.1:1130 - i am the second client New connection , socket fd is 3944 , ip is : 127.0.0.1 , port : 1131 Welcome message sent successfully Adding to list of sockets at index 2 127.0.0.1:1131 - and i am the third 127.0.0.1:1131 - ha ha ha

Now thats a long run. I will go and take a cup of coffee, and meanwhile you check if the programs are running fine.