C UDP Echo Program

The UDP Client-Server Flow

As a quick refresher from last time, let's visualize the sequence of calls we are about to implement.

The server is passive; it sets up shop and waits. The client is active; it initiates the conversation. We will build and analyze the code for each part separately.

Implementing the UDP Echo Server

The server's job is to wait for a datagram on a specific port, and when one arrives, to send it right back to the sender—hence, an "echo" server.

The resource below contains well-commented C code for a UDP server. I'd like you to download or copy this code into a file named server_udp.c. We'll then break it down piece by piece.

Now, let's dissect the key parts of server_udp.c.

1. Creating the Socket:

   sock=socket(AF_INET, SOCK_DGRAM, 0);
   

   This should look familiar. We request a socket for the Internet address family (AF_INET) but specify the type as SOCK_DGRAM, indicating we want to use the UDP protocol.

2. Binding the Socket to a Port:

   server.sin_family = AF_INET;
   server.sin_addr.s_addr = INADDR_ANY;
   server.sin_port = htons(atoi(argv[1]));
   
   if (bind(sock,(struct sockaddr *)&server,sizeof(server)) < 0) 
       error("Binding");
   

   The server binds to the port number provided as a command-line argument (argv[1]). The use of INADDR_ANY allows the socket to receive packets destined for any of the machine's IP addresses on that port. This is standard practice for servers. Crucially, the port number is converted to network byte order using htons() ("host to network short"). We'll touch on this again shortly.

3. Receiving and Replying in a Loop:

   while (1) {
       n = recvfrom(sock,buf,1024,0,(struct sockaddr *)&from,&fromlen);
       if (n < 0) error("recvfrom");
   
       // ... code to print what was received ...
   
       n = sendto(sock,"Got your message",17,0,(struct sockaddr *)&from,fromlen);
       if (n  < 0) error("sendto");
   }
   

   This is the core of the server's logic:

   • recvfrom(): The program blocks here, waiting for a datagram. When one arrives, recvfrom does two things: it copies the message into buf and it populates the from struct with the source IP address and port of the client.
   • sendto(): To send the echo reply, the server calls sendto. Critically, it uses the from address structure it just received as the destination. This ensures the reply goes back to the correct client.

Implementing the UDP Echo Client

The client's job is to get a message from the user, send it to the server's address, wait for the echo, and print it.

Similar to the server, let's get the client code. Please copy this into a file named client_udp.c.

Let's analyze the key parts of client_udp.c.

1. Creating the Socket and Finding the Server:

   sock= socket(AF_INET, SOCK_DGRAM, 0);
   
   server.sin_family = AF_INET;
   hp = gethostbyname(argv[1]);
   bcopy((char *)hp->h_addr, (char *)&server.sin_addr, hp->h_length);
   server.sin_port = htons(atoi(argv[2]));
   

   The client also creates a SOCK_DGRAM socket. It then populates a sockaddr_in struct (server) with the destination address. It uses gethostbyname() to look up the server's IP from the hostname given in argv[1] and sets the port from argv[2].

2. Sending and Receiving Data:

   // Gets message from user into buffer 'buf'
   printf("Please enter the message: ");
   bzero(buf,256);
   fgets(buf,255,stdin);
   
   n=sendto(sock,buf,strlen(buf),0,(const struct sockaddr *)&server,length);
   if (n < 0) error("Sendto");
   
   n = recvfrom(sock,buf,256,0,(struct sockaddr *)&from, &length);
   if (n < 0) error("recvfrom");
   

   • sendto(): The client sends the user's message using sendto, specifying the server address structure as the destination. Notice the client does not call bind(). The OS will automatically assign an ephemeral port to the client's socket, and the server will learn this port via recvfrom.
   • recvfrom(): The client then blocks on recvfrom, waiting for the server's echo reply.

A Critical Detail: Network Byte Order

You've seen htons() used in the code. Why is this necessary?

Computers can store multi-byte numbers like integers in two ways: big-endian (most significant byte first) or little-endian (least significant byte first). To ensure that two computers can communicate regardless of their native format, network protocols like IP define a standard order: Network Byte Order, which is big-endian.

The socket API provides functions to convert between your host's byte order and network byte order.

• htons(): host to network short (16-bit, for port numbers)
• htonl(): host to network long (32-bit, for IP addresses)
• ntohs(): network to host short
• ntohl(): network to host long

Forgetting to use these functions is a very common bug in network programming, as your code might work when the client and server are on the same machine (which likely has the same byte order) but fail when they are on different ones.

Hands-On: Compile and Run Your Echo Service

Now it's time to bring your programs to life.

1. Open two terminal windows. One will be for the server, the other for the client.

2. Compile the code. In each terminal, run the appropriate gcc command.

   
   
   
   # In terminal 1: Compile the server
   gcc server_udp.c -o server
   
   
   
   
   # In terminal 2: Compile the client
   gcc client_udp.c -o client
   

3. Run the server. Choose a high port number (e.g., above 2000) to avoid conflicts.

   
   
   
   # In terminal 1:
   ./server 9999
   

   The server will start and then appear to hang. It's actually blocking on the recvfrom() call, waiting for a client.

4. Run the client. In the other terminal, run the client, telling it to connect to your local machine (localhost) on the port your server is using.

   
   
   
   # In terminal 2:
   ./client localhost 9999
   

5. Test the communication. The client will prompt you for a message. Type something and press Enter. You should see the server receive the message and print it, and the client should receive the echo and print "Got an ack: ..."

Congratulations! You've just implemented a working UDP client-server program.

To see another demonstration of this entire process, you can watch the following video. It builds a similar program from scratch and shows the compilation and execution steps.

Conclusion

In this lesson, you successfully transitioned from theory to practice by implementing a complete UDP echo client-server application in C. This is a significant milestone in your journey to understanding how the internet works at a fundamental level.

Key Takeaways:

• UDP Server Logic: Create a SOCK_DGRAM socket, bind() it to a well-known port, and enter a loop that calls recvfrom() to get a message and the client's address, then sendto() to send a reply back to that address.
• UDP Client Logic: Create a SOCK_DGRAM socket, populate a sockaddr_in struct with the server's address and port, and use sendto() to send a message, followed by recvfrom() to await the reply.
• sendto() and recvfrom() are the workhorses of UDP, as they handle both data transfer and addressing for each individual datagram.
• Network Byte Order is crucial: Always use functions like htons() and htonl() to ensure your address and port data are in the standardized network format.

Preview of the Next Lesson:

Your client program needed to know the server's address (localhost or an IP address) to function. But in the real world, you don't type 216.58.204.78 into your browser; you type google.com. How does your computer translate that human-readable name into a machine-usable IP address? That is the job of the Domain Name System (DNS). In our next lesson, we will explain the purpose of DNS in translating domain names to IP addresses.