send_data [strlen (send_data) - ONE] = '\0';

fgets() reads in at most one less than size characters from stream  and
       stores  them  into  the buffer pointed to by s.  Reading stops after an
       EOF or a newline.  If a newline is read, it is stored into the  buffer.
       A '\0' is stored after the last character in the buffer.

recv_data[bytes_read] = '\0';

//                printf("\n%s said : ", inet_ntoa(client_addr.sin_addr));
//                printf("%s", recv_data);
        printf("%s said : %s\n", inet_ntoa(client_addr.sin_addr), recv_data);

/*=========client PGM=========================*/
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define MAX   1024
#define CLINO 5
#define PORT  5000
#define PORT2 5001

int main(int argc, char **argv)
{
	const char *name="localhost";
	unsigned int sock, bytes_read, addr_len;
	struct sockaddr_in server_addr, client_addr;
	struct hostent *host;
	char send_data[MAX], recv_data[MAX];

	unsigned int sock2, bytes_read2, addr_len2;
	struct sockaddr_in server_addr2, client_addr2;
	char send_data2[MAX], recv_data2[MAX];

	struct timeval tv, tv1;
	fd_set writefds, readfds;

/*	tv1.tv_sec = 2;
	tv1.tv_usec = 500000;
*/

	// 'name' is already localhost, so localhost will be used with no args
	if(argc == 2)		name=argv[1];

	host = (struct hostent *) gethostbyname(name);
	
	if ((sock = socket (AF_INET, SOCK_DGRAM, 0)) == -1) {
		perror ("Socket error");
		exit (EXIT_FAILURE);
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(PORT);
	server_addr.sin_addr = *((struct in_addr *)host->h_addr);
	bzero (&(server_addr.sin_zero), 8);
	bzero (recv_data, MAX);
	
	if ((sock2 = socket (AF_INET, SOCK_DGRAM, 0)) == -1) {
		perror ("Socket2 error");
		exit (EXIT_FAILURE);
	}
	
	server_addr2.sin_family = AF_INET;
	server_addr2.sin_port = htons(PORT2);
	server_addr2.sin_addr = *((struct in_addr *)host->h_addr);
	bzero (&(server_addr2.sin_zero), 8);
	bzero (recv_data2, MAX);
	
	FD_ZERO (&writefds);
/*	FD_ZERO (&readfds);
	FD_SET (sock2, &readfds);
*/
	while (1) {
		int n;

		printf ("Type Something for socket1 :");
		fgets (send_data, MAX, stdin);
                // strlen doesn't work without a NULL!  send_data already has one!
		// send_data [strlen (send_data) - 1] = '\0';
		
		sendto(sock, send_data, strlen(send_data), 0 ,
			(struct sockaddr *)&server_addr, sizeof(struct sockaddr));

		// Need to set this every loop.  select() clears if
		// the socket's inactive, but never sets it for you.
		FD_SET (sock2, &writefds);

		// select() alters this, so must set this EVERY time.
		// pselect() is more polite.
		tv.tv_sec = 10;
		tv.tv_usec = 500000;
		n=select (sock2+1, NULL, &writefds, NULL, &tv);

		// use a continue instead of 9 levels of nesting
		if(n == 0)
		{
			printf("Timed out RTCP Send at client side\n");
			continue;
		}
		// use an exit() instead of 9 levels of nesting
		if(n < 0)
		{
			perror("select error'");
			exit(1);
		}

		// use a continue, instead of 9 levels of nesting
		if(!FD_ISSET (sock2, &writefds))
		{
			printf ("Timed out RTCP Send at client side\n");
			continue;
		}

		printf("Enter the data from the 2nd socket:  ");
		fgets (send_data2, MAX, stdin);
                // strlen doesn't work without a NULL!  send_data2 already has one!
		// send_data2 [strlen (send_data2) - 1] = '\0';
		sendto(sock2, send_data2, strlen(send_data2), 0 ,
			(struct sockaddr *)&server_addr2, sizeof(struct sockaddr));
	}
	return 0;
}

/*========= Server PGM =========================*/
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define MAX   1024
#define CLINO 5
#define PORT  5000
#define PORT2 5001

int main(int argc, char **argv)
{
	const char *name=NULL;
        int sock;
        unsigned int addr_len, bytes_read;
        char recv_data[MAX], send_data[MAX];
        struct sockaddr_in server_addr ,client_addr;
	
        int sock2;
        unsigned int addr_len2, bytes_read2;
        char recv_data2[MAX], send_data2[MAX];
        struct sockaddr_in server_addr2 ,client_addr2;

	struct timeval tv, tv1;
	fd_set readfds, writefds;

	tv.tv_sec = 5;
	tv.tv_usec = 500000;
/*	tv1.tv_sec = 2;
	tv1.tv_usec = 500000;
*/
	if (argc != 2) {
		printf ("Usage: ./server <client_ip>\n");
		exit (EXIT_FAILURE);
	}

	if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
		perror("Socket error");
		exit(EXIT_FAILURE);
        }

	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(PORT);
	server_addr.sin_addr.s_addr = INADDR_ANY;
	bzero(&(server_addr.sin_zero), 8);


	if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
		perror("Bind error");
		exit(EXIT_FAILURE);
	}

	addr_len = sizeof(struct sockaddr);
	
	if ((sock2 = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
		perror("Socket2 error");
		exit(EXIT_FAILURE);
        }

	server_addr2.sin_family = AF_INET;
	server_addr2.sin_port = htons(PORT2);
	server_addr2.sin_addr.s_addr = INADDR_ANY;
	bzero(&(server_addr2.sin_zero), 8);


	if (bind(sock2, (struct sockaddr *)&server_addr2, sizeof(struct sockaddr)) == -1) {
		perror("Bind2 error");
		exit(EXIT_FAILURE);
	}

	addr_len2 = sizeof(struct sockaddr);
	printf("UDP Server Waiting for client on port 5000\n");
        fflush(stdout);

	FD_ZERO (&readfds);

	while (1) {
		int n;
		// Set this every loop, select() will clear if idle
		FD_SET (sock2, &readfds);

		// select actually ALTERS tv!  You must put these values 
		// in every loop.  pselect() is more polite.
		tv.tv_sec = 5;		tv.tv_usec = 500000;
		n=select(sock2+1, &readfds, NULL, NULL, &tv);

		// use an exit instead of 9 levels of nesting
		if(n< 0)
		{
			perror("select error");
			exit (1);
		}

		// use a continue instead of 9 levels of nesting
		if(n == 0)
		{
			printf("select() timeout\n");
			continue;
		}

		// n must be 1 or more, i.e. 1 or more sockets ready,
		// beyond this point.

		printf("%d fd's ready\n", n);
		
		bytes_read = recvfrom(sock, recv_data, MAX, 0, (struct sockaddr *)&client_addr, &addr_len);
		recv_data[bytes_read] = '\0';
		printf("%s said : %s\n", inet_ntoa(client_addr.sin_addr),
			recv_data);

		// use a continue instead of 9 levels of nesting
		if(!FD_ISSET(sock2, &readfds))
		{
			printf("sock2 not ready on server side\n");
			continue;
		}

		bytes_read2 = recvfrom(sock2, recv_data2, MAX, 0, (struct sockaddr *)&client_addr2, &addr_len2);
		recv_data2[bytes_read2] = '\0';
		printf("%s said : %s\n",
			inet_ntoa(client_addr2.sin_addr), recv_data2);
		printf ("Socket 2\n");
		
		// fflush is not necessary when you print \n on the end!
		//	fflush(stdout);
	}
	return 0;
}