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);

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 bind the socket to this port as follows

		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

		char pkt[300];
		sprintf(pkt,"hello there\n");
		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);
		fd_set readFd;
		timeval SelectTime;
		SelectTime.tv_sec = 2;// wait 2 seconds
		SelectTime.tv_usec=0;
		FD_ZERO(&readFd);
		FD_SET(UDPSock,&readFd);
		ret = Selec(255,&readFd,NULL,NULL,&SelectTime);
		if (FD_ISSET(UDPSock, &readFD)==1)
		{
			ret = recv(UDPSock, (char *)pkt, 300,0);
			printf("received:  %s",pkt);
		}
		else
		{
			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);
		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));
		printf("%s",buf);
		sprintf(buf,"go away\n");
		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);