Using client-side sockets in datagram mode

In C language:

After creating the socket, you will have to send a first datagram to the server via the sendto function which requires 6 parameters:

• fd: The first parameter is the integer returned from the socket creation system call.
• buffer: The second parameter is the memory address of the buffer containing the message to send
• len: The third parameter is an integer indicating the number of bytes to send.
• flags: The fourth parameter is a combination of flags defined by the following constants.
• MSG_CONFIRM: This indicates that we are waiting for a response packet from the server.
• MSG_DONTWAIT: Asks to be warned by an error if the sending operation was blocking.
• addr: The fifth parameter is the address in memory of a structure of the type sockaddr used to specify the IP address and the UDP port of the target server. (It is a generic structure which is used to encompass several other structures whose contents vary according to the value of the first field which is named sa_family in the structure sockaddr).
• addr_len: The sixth parameter is the size of the structure passed as the fifth parameter.

We will therefore have to declare a variant of the sockaddr structure corresponding to AF_INET. This is the struct sockaddr_in type. We will start by zeroing the content of this structure via the bzero function of string.h, then we will assign, to the first field, named here sin_family, the AF_INET value.

struct sockaddr_in	addr;

bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
	

You must then fill in the structure, the sin_addr field with the IPv4 address of the server to contact and the sin_port field with the number of its UDP port.

Notes:

• The IPv4 address must be coded on 4 bytes, we will use a function of the arpa/inet.h library to convert its writing in the form of a character string (4 numerical values between 0 and 255 separated by periods) in the expected format. This is the inet_aton function which takes the string as the first parameter and the address of the field in which you want to place the result as the second parameter. The returned value is 0 unless the supplied string is not in IPv4 format.
• The port is an (unsigned) integer coded on 2 bytes and stored in the direction of most significant byte first and least significant byte then according to the convention chosen by the TCP/IP protocols. However, depending on the type of CPU, the convention used is not necessarily the same. With some types of CPU, it will be necessary to cross the two bytes and not with other types of CPU. To facilitate the process without asking questions, the arpa/inet.h library provides the htons() function which converts the unsigned short integer passed as a parameter from the host to network byte order and return the result.

inet_aton("127.0.0.1", &addr.sin_addr);
addr.sin_port = htons(7);
	

Having thus specified the address 127.0.0.1 and the port 7, all that remains is to call the sendto function so that the client tries to establish the connection with the local echo server.

sendto(fd, &buffer, sizeof(buffer), MSG_CONFIRM, (struct sockaddr *) &addr, sizeof(addr));
	

• Without the "cast" to the type corresponding to the generic structure struct sockaddr *, there is a warning from the C compiler.

Example:

#include <stdio.h>
#include <stdlib.h>

#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>

#include <string.h>		// for the functions bzero and strlen
#include <arpa/inet.h>	// for the function inet_addr

int main()
{
	int fd;
	struct sockaddr_in addr;
	int err;
	char buffer[]="Hello !";

	fd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (fd<0) {
		printf("Socket creation error!\n");
		exit(1);
	}

	bzero(&addr, sizeof(addr));
	addr.sin_family = AF_INET;
	err = inet_aton("127.0.0.1", &addr.sin_addr);
	if (err == 0) {
		printf("Invalid IPv4 address!\n");
		exit(1);
	}
	addr.sin_port = htons(8080);

	sendto(fd, &buffer, strlen(buffer), MSG_CONFIRM, (struct sockaddr *) &addr, sizeof(addr)); 

	printf("Message sent to server!\n");
	return 0;
}
	

PHP and Python:

In languages like PHP or Python, there are libraries interfacing with system functions.

PHP

The example code written in C becomes in PHP:

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if ($socket == false) die("Socket creation error!\n");
$buffer = "Hello !";
$len = strlen($buffer);
socket_sendto($socket, $buffer, $len, '127.0.0.1', 8080);
echo "Message sent to server!\n";
	

Python

The example code written in C becomes in Python:

try :
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sock.sendto("Hello !",('127.0.0.1',8080))
except socket.error :
	print("Customer communication error!")
	exit()
print("Message sent to server!")