Basic Server/Client Application - Network Programming

   Today, I’d like to get into programming sockets, and help explain a little about network programming.  While network programming is a lot to understand, it is easy to understand once you get the hang of the basic functions needed to get a client-server connection established. First let’s go through some basic terminology of networking.

Sockets: There are object inside of the source code that create an interface with the network, and act as a connection to the transport layer of the IP(Internet Protocol).

Client: The local application a user starts is called the application.

Server: The application on the end that receives messages from the client’s application instance.

Protocol: A protocol is a system of rules for the exchange of data across a network. There are many protocols, made up of layers for each protocol used by an application. For this tutorial, we will be utilizing the UDP protocol for passing a basic message. There is also the TCP protocol, which came first and serves a different purpose, but with the same principal; to enable the transfer of data.

Port: A number, specifying the location for the protocol to be used on the transport layer (i.e. 80 is for HTTP, which is used to browse the web.)

Internet Address: A 12 character number, which describes the location of the physical computer used for an application; Necessary for finding and establishing a connection to the client’s and to connect to the server.

   Ok, now that we have an understanding of the terms for a network application, let’s get into a basic networking application. Both files are quite similar, so lets start with defining the methods used:

struct sockaddr_in sockServer, sockClient;

WSADATA wsa;

SOCKET s, c;

int slen = sizeof(sockClient) , recv_len;

char buf[BUFLEN];

   The first few lines in main() set some variables and data structures to be used in the application. The first two are structures, called sockaddr_in. These are socket address interface object, and they store the socket information for our application, for the client and the server. The second of the two variables are the SOCKET variables, which act an the interface objects to the transport layer of the IP suite. The next variable is the WSADATA variable; this is a winsock specific variable, and we will need to initialize this in order to get the application to work on windows correctly. There is also two integers for measuring the length of the socket (slen) and of the data incoming (recv_len). The final variable, buf[], is the buffer for our data; an array of characters, with BUFLEN as a defined value constant for determining the length of the message.

if(WSAStartup(MAKEWORD(2,2),&wsa) != 0)

       {

           printf("Failed. Error Code : %d",WSAGetLastError());

       }

   This if loop will setup WinSock for our application with the wsa variable, and return a error message if it can't initialize properly.

s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

   This is where the server socket is initialized. AF_INET tells this socket that it will be used over the internet. SOCK_DGRAM tells this socket to send data as a datagram, and the third parameter, IPPROTO_UDP will set the protocol used to UDP (User Datagram Protocol).

sockServer.sin_family = AF_INET;

sockServer.sin_port = htons(SERVERPORT);

sockServer.sin_addr.s_addr = inet_addr("127.0.0.1");

   These lines of code will initialize the sockaddr_in object with information about the computer being connected to. The first line is AF_INET, which tells the structure to use the IP suite. The second one assigned a port number - this instance has the user assigned a port number to a specific number, but normally this area is used for port numbers used for protocol numbers like HTTP (80) or UDP (67). And inet_addr assigns a numerical address to the structure, to identify the specific computer to connect to. In this case, the number "127.0.0.1" is used to indicate the local host, meaning that same computer used for the server is also the same address for the client; we will be using this for the tutorial to keep this simple, and I will go into this later on.

bind(s , (struct sockaddr*)&sockServer, sizeof(sockServer) );

  Before the main loop our application utilizes, we call bind, to bind the socket 's' to the address structure 'sock'server'. This means calling the sizeof() method for the structure as well.

recv_len = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *) &sockClient, &slen);

   This line of code start with the variable; that variable will get the number of bytes received from the incoming data. That value is returned from the recv_from() method.

   The recv_from() method receives data from another computer; this is the method to test for incoming data. The first parameter in the recv_from method is the bound socket, for our current application. The second and third parameters are the buffer for the data and the buffer size, respectively. The fourth parameter is for setting flags ('0' in this case). The fifth parameter take a sockaddr_in object, passing the address information from the source into the object. And the sixth parameter takes the size in bytes of the fifth parameter's structure.

sendto(c, buf, recv_len, 0, (struct sockaddr*) &sockClient, slen);

   This method finally sends the data out to another computer; the sendto() method. The parameters in this method are identical to the recv_from arguments; the main difference is that all the parameters are inputs, meaning all the objects in the sendto() method are being utilized, and no data is sent out from this function to any of the objects passed as arguments, unlike recv_from().

closesocket(c);

   Finally, we call closesocket() to close the socket in use. This takes a single parameter, the socket. It is pretty simple to understand.

I’ve included the source code for both the client and the server instances below for you to run; just remember to run the server application first before using the client. I hope this tutorial was helpful in illuminating exactly how an application works over the internet. It serves to show exactly how an application works from a windows stand point.

   To compile, simply put both files in a directory, navigate to that directory with cd, then, assuming you have GCC, type g++ -Wall server.c –o serverAppName.exe –lWs2_32. Please remember the –l and Ws2_32, as these are the libraries for Windows to work with sockets. Without them the application will not work.

Have a fantastic day! :D

Server Code:

#include <stdio.h> //printf

#include <string.h> //memset

#include <stdlib.h> //exit(0)

#ifdef WIN32

#include <winsock2.h>

#include <winsock.h>

#else

#include <arpa/inet.h>

#include <sys/socket.h>

#endif

#define BUFLEN 512  //Max length of buffer

#define SERVERPORT 1111   //The port on which to listen for incoming data

#define CLIENTPORT 1112

int main(int argc, char **argv)

{

    struct sockaddr_in sockServer, sockClient;

       WSADATA wsa;

    SOCKET s, c;

       int slen = sizeof(sockClient) , recv_len;

    char buf[BUFLEN];

      

       if(WSAStartup(MAKEWORD(2,2),&wsa) != 0)

       {

           printf("Failed. Error Code : %d",WSAGetLastError());

       }

    

    //create a UDP socket

    s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    

    // zero out the structure

    memset((char *) &sockServer, 0, sizeof(sockServer));

    

       //Assign IP address and port number for the server

    sockServer.sin_family = AF_INET;

    sockServer.sin_port = htons(SERVERPORT);

    sockServer.sin_addr.s_addr = inet_addr("127.0.0.1"); //Localhost

    

    //bind socket to the port number

    bind(s , (struct sockaddr*)&sockServer, sizeof(sockServer) );

    

    //keep listening for data

    while(1)

    {

              //Send message and clear standard buffers

        printf("Waiting for data...");

        fflush(stdout);

              fflush(stdin);

        

        //try to receive some data, this is a blocking call

        recv_len = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *) &sockClient, &slen);

             

              //print details of the client/peer and the data received

              printf("Received packet from %s:%d\n", inet_ntoa(sockClient.sin_addr), ntohs(sockClient.sin_port));

              buf[recv_len];

              printf("Data: %s\n" , buf);

                    

              //Create client socket for server side connection.

              c = socket(AF_INET, SOCK_DGRAM, 0);

             

              sockClient.sin_family = AF_INET;

              sockClient.sin_port = htons(CLIENTPORT);

              sockClient.sin_addr.s_addr = inet_addr("127.0.0.1");

        

        //now reply the client with the same data

        sendto(c, buf, recv_len, 0, (struct sockaddr*) &sockClient, slen);

             

              //Close the socket connection the server to the client

              closesocket(c);

    }

      

       //Close the server socket and close the application

       closesocket(s);

    WSACleanup();

      

    return 0;

}

Client Code:

#include<stdio.h> //printf

#include<string.h> //memset

#include<stdlib.h> //exit(0)

#ifdef WIN32

#include <winsock2.h>

#include <winsock.h>

#else

#include <arpa/inet.h>

#include<sys/socket.h>

#endif

#define BUFLEN 512  //Max length of buffer

#define SERVERPORT 1111   //The port on which to listen for incoming data

#define CLIENTPORT 1112

int main(int argc, char **argv)

{

    struct sockaddr_in sockHost, sockServer;

    SOCKET s, c;

       WSADATA wsa;

       int slen = sizeof(sockServer) , recv_len;

    char buf[BUFLEN];

    

       if(WSAStartup(MAKEWORD(2,2),&wsa) != 0)

       {

           printf("Failed. Error Code : %d",WSAGetLastError());

       }

      

    //create a UDP socket

    c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    

    // zero out the structure

    memset((char *) &sockHost, 0, sizeof(sockHost));

    

    sockHost.sin_family = AF_INET;

    sockHost.sin_port = htons(CLIENTPORT);

    sockHost.sin_addr.s_addr = inet_addr("127.0.0.1"); //Localhost

    

    //bind socket to port

    bind(c , (struct sockaddr*)&sockHost, sizeof(sockHost) );

    

    //keep listening for data

    while(1)

    {

              //Get input from the user, and put the data into the buffer

        printf("Input data...");

        fflush(stdin);

              fgets(buf, 512, stdin);

              printf("Client: %s", buf);

             

              //Create the client-side socket for the server

              s = socket(AF_INET, SOCK_DGRAM, 0);

              sockServer.sin_family = AF_INET;

              sockServer.sin_port = htons(SERVERPORT);

              sockServer.sin_addr.s_addr = inet_addr("127.0.0.1");

             

        //now reply the server with the input data

        sendto(s, buf, BUFLEN, 0, (struct sockaddr*) &sockServer, slen);

             

              closesocket(s);

             

        //receive some data, this is a blocking call

        recv_len = recvfrom(c, buf, BUFLEN, 0, (struct sockaddr *) &sockServer, &slen);

        

              printf("Server: %s", buf);

    }

    closesocket(c);

       WSACleanup();

    return 0;

}