Say hello to another host with UDP

for linux and unix

In this assignment two hosts will communicate with each other using UDP. While the idea is that there are two programs on two different hosts, it is possible to run the two programs on the same machine.

There are two types of hosts (and hence two programs), client and server.

The server tasks are: setup, receive data, and send data
The client tasks are setup, send data, and receive data.

More specifically,

The server must

Setup the socket to communicate on port 10000.
Wait for data to be received.
Print the received data.
Send data to where ever the received data came from.

The client must

Setup the socket to communicate on port 10001.
Sent data to the server, i.e., to the IP address of the server and to port 10000
Wait for data
Print the received data

Includes and Definitions

#include <sys/time.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h> /* this might not be needed*/

Setup the socket

int UDPSock;
UDPSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);  /* IPPROTO_UDP - so this will be a UDP Socket */

Bind to socket to a port (This both client and server)

This will make the socket receive data from a particular port. Also, when data is sent with this socket, the source port of the data will be this port.

For the server, define the port:

		int UDPPort =  10000;

For the client, define the port:

		int UDPPort =  10001;

Now we define and bind the socket to this port as follows

		/* set up socket */
		struct sockaddr_in My;
		memset(&My,0,sizeof(My));// clear memory
		My.sin_family = AF_INET;		// must be this
		My.sin_addr.s_addr = htonl(INADDR_ANY);
		My.sin_port = htons(UDPPort);		// the port on this host

		/* BIND THE SOCKET TO Port  */
		int ret=bind(UDPSock, (struct sockaddr *)&My, sizeof(struct sockaddr));
		printf("bind returned %d if not zero, then there was a problem\n",ret);

For the client: define where the data is to be sent. Specifically, define the IP address and port.

		char ToIPAddress[80];
		sprintf(ToIPAddress,"128.4.132.43");  // put the IP of the server
		int WriteToPort = 10000; // the client will write to 10000
		struct sockaddr_in to;
		memset(&to,0,sizeof(to));
		to.sin_addr.s_addr = inet_addr(ToIPAddress);
		to.sin_family = AF_INET;
		to.sin_port = htons(WriteToPort); // set port address

For the client: define the data to be send, send it, and then wait for a response

		/* make message */
		char pkt[300];
		sprintf(pkt,"hello there\n");

		/* send message */
		ret = sendto(UDPSock, (char *)pkt, sizeof(pkt), 0, (struct sockaddr *)&to, sizeof(struct sockaddr));
		printf("sendto returned %d it should be   the number of bytes sent \n",ret);

		/* wait for return message */
		fd_set readFd;
		struct timeval SelectTime;
		SelectTime.tv_sec = 2; /* set timeout to 2 seconds. If no messages arrives in 2 seconds, then give up */
		SelectTime.tv_usec=0;
		FD_ZERO(&readFd);
		FD_SET(UDPSock,&readFd);
		ret = select(255,&readFd,NULL,NULL,&SelectTime); /* wait for message */
		if (FD_ISSET(UDPSock, &readFd)==1) 
		{	/* is message arrived before timeout */
			ret = recv(UDPSock, (char *)pkt, 300,0);
			printf("received:  %s",pkt);
		}
		else
		{	/* if message failed to arrive before timeout */
			printf("no response from %s\n",ToIPAddress);
		}

For the server: Wait for data to be received, receive it, and print it.

		char buf[300];
		struct sockaddr_in from;
		int len = sizeof(struct sockaddr);


		/* wait for message. This will wait forever for a message. If a timeout is needed, then use Select, as shown above */
		ret = recvfrom(UDPSock, (char *)buf, 300, 0,(struct sockaddr *)&from,(socklen_t *)&len);
		printf("recv returned %d\n",ret);
		printf("received data from %s from port %d\n",inet_ntoa(from.sin_addr),ntohs(from.sin_port));

		/* make message to send */
		sprintf(buf,"go away\n");
		printf("%s",buf);
	
		/* send message */
		struct sockaddr_in to;
		memset(&to,0,sizeof(to));
		to.sin_addr.s_addr = from.sin_addr.s_addr;
		to.sin_family = AF_INET;
		to.sin_port = from.sin_port; // set port address
		ret = sendto(UDPSock, (char *)buf, 300, 0, (struct sockaddr *)&to, sizeof(struct sockaddr));
		printf("sendto returned %d\n",ret);