UDP Server-Client implementation in C++
Last Updated :
23 Feb, 2023
There are two primary transport layer protocols to communicate between hosts: TCP and UDP. Creating TCP Server/Client was discussed in a previous post.
Prerequisite: Creating TCP Server/Client
Theory: In UDP, the client does not form a connection with the server like in TCP and instead sends a datagram. Similarly, the server need not accept a connection and just waits for datagrams to arrive. Datagrams upon arrival contain the address of the sender which the server uses to send data to the correct client.
The entire process can be broken down into the following steps :
UDP Server :
- Create a UDP socket.
- Bind the socket to the server address.
- Wait until the datagram packet arrives from the client.
- Process the datagram packet and send a reply to the client.
- Go back to Step 3.
UDP Client :
- Create a UDP socket.
- Send a message to the server.
- Wait until a response from the server is received.
- Process the reply and go back to step 2, if necessary.
- Close socket descriptor and exit.
Necessary Functions :
int socket(int domain, int type, int protocol)
Creates an unbound socket in the specified domain.
Returns socket file descriptor.
Arguments :
domain - Specifies the communication
domain ( AF_INET for IPv4/ AF_INET6 for IPv6 )
type - Type of socket to be created
( SOCK_STREAM for TCP / SOCK_DGRAM for UDP )
protocol - Protocol to be used by the socket.
0 means using the default protocol for the address family.
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
Assigns address to the unbound socket.
Arguments :
sockfd - File descriptor of a socket to be bonded
addr - Structure in which the address to be bound to is specified
addrlen - Size of addr structure
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen)
Send a message on the socket
Arguments :
sockfd - File descriptor of the socket
buf - Application buffer containing the data to be sent
len - Size of buf application buffer
flags - Bitwise OR of flags to modify socket behavior
dest_addr - Structure containing the address of the destination
addrlen - Size of dest_addr structure
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen)
Receive a message from the socket.
Arguments :
sockfd - File descriptor of the socket
buf - Application buffer is a pointer which receives the data
len - Size of buf application buffer
flags - Bitwise OR of flags to modify socket behavior
src_addr - Structure containing source address is returned
addrlen - Variable in which the size of src_addr structure is returned
int close(int fd)
Close a file descriptor
Arguments:
fd - File descriptor
In the below code, the exchange of one hello message between the server and client is shown to demonstrate the model.
Filename: UDPServer.c++
C++14
// Server side implementation of UDP client-server model
#include <bits/stdc++.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define PORT 8080
#define MAXLINE 1024
// Driver code
int main() {
int sockfd;
char buffer[MAXLINE];
const char *hello = "Hello from server";
struct sockaddr_in servaddr, cliaddr;
// Creating socket file descriptor
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
// Filling server information
servaddr.sin_family = AF_INET; // IPv4
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);
// Bind the socket with the server address
if ( bind(sockfd, (const struct sockaddr *)&servaddr,
sizeof(servaddr)) < 0 )
{
perror("bind failed");
exit(EXIT_FAILURE);
}
socklen_t len;
int n;
len = sizeof(cliaddr); //len is value/result
n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, ( struct sockaddr *) &cliaddr,
&len);
buffer[n] = '\0';
printf("Client : %s\n", buffer);
sendto(sockfd, (const char *)hello, strlen(hello),
MSG_CONFIRM, (const struct sockaddr *) &cliaddr,
len);
std::cout<<"Hello message sent."<<std::endl;
return 0;
}
Filename: UDPClient.c++
C++14
// Client side implementation of UDP client-server model
#include <bits/stdc++.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define PORT 8080
#define MAXLINE 1024
// Driver code
int main() {
int sockfd;
char buffer[MAXLINE];
const char *hello = "Hello from client";
struct sockaddr_in servaddr;
// Creating socket file descriptor
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
// Filling server information
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
int n;
socklen_t len;
sendto(sockfd, (const char *)hello, strlen(hello),
MSG_CONFIRM, (const struct sockaddr *) &servaddr,
sizeof(servaddr));
std::cout<<"Hello message sent."<<std::endl;
n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, (struct sockaddr *) &servaddr,
&len);
buffer[n] = '\0';
std::cout<<"Server :"<<buffer<<std::endl;
close(sockfd);
return 0;
}
Output :
$ ./server
Client : Hello from client
Hello message sent.
$ ./client
Hello message sent.
Server : Hello from server
Similar Reads
Handling multiple clients on server with multithreading using Socket Programming in C/C++
This tutorial assumes that the reader has a basic knowledge of socket programming, i.e has a familiarity with basic server and client models. In the basic model, the server handles only one client at a time, which is a big assumption if one wants to develop any scalable server model. The simple way
6 min read
TCP Client-Server Program to Check if a Given String is Palindrome
Prerequisites: Socket Programming in C/C++, TCP and UDP server using select, UDP Server-Client implementation in C TCP Client-Server Implementation in C This article describes a Client and Server setup where a Client connects, sends a string to the server and the server shows the original string and
4 min read
Design a concurrent server for handling multiple clients using fork()
Prerequisite: Socket Programming in C/C++, fork() System call Problem Statement: In this article, we are going to write a program that illustrates the Client-Server Model using fork() system call which can handle multiple clients concurrently. Fork() call creates multiple child processes for concu
6 min read
C program for file Transfer using UDP
Data can be transferred between two computers using Socket programming in C. Similarly, files can easily be sent using UDP protocol and a simple client/server. Security: Handled by encryption. Protocol : UDP Encryption: XOR encryption Algorithm : 1. The server starts and waits for filename. 2. The c
4 min read
Producer Consumer Problem in C
Concurrency is an important topic in concurrent programming since it allows us to completely understand how the systems work. Among the several challenges faced by practitioners working with these systems, there is a major synchronization issue which is the producer-consumer problem. In this article
5 min read
How to use make utility to build C projects?`
When we build projects in C/C++, we have dependencies among files. For example, there might be a file a.c that calls a function from b.c. So we must compile b.c before a.c. There might be many dependencies in a project and manually following these dependencies and compiling files one by one becomes
5 min read
TCP Server-Client implementation in C
Prerequisites - Socket Programming in C/C++, TCP and UDP server using select, UDP Server-Client implementation in C If we are creating a connection between client and server using TCP then it has a few functionalities like, TCP is suited for applications that require high reliability, and transmissi
4 min read
UDP Client Server using connect | C implementation
UDP is a connection less protocol. There is no connection is established between client and server. Creating Standard UDP Client/Server is discussed here Prerequisite : Socket Programming in C/CPP | UDP server-client implementation In UDP, the client does not form a connection with the server like i
3 min read
Types of Software Defined Networks Implementation
The implementation of SDN varies very much from the conventional network. In traditional networking, the data packet forwarding and routing happen in the same device. Whereas in SDN it is separated into two planes as data plane and control plane. In every SDN implementation, there are three elements
4 min read
Design and Implementation Issue of Distributed Shared Memory
DSM is a mechanism that manages memory across multiple nodes and makes inter-process communications transparent to end-users. To design information shared memory we might deal with certain issues which are called issues. Issues to Design and Implementation of DSM: GranularityStructure of shared memo
3 min read