Network Programming Lab

Submit by Guided By:

.. ..

. .

.
 INDEX

S No. Topic page date remark sign

1 Write an echo program with client and iterative server
using TCP.
2 Write an echo program with client and iterative server
using TCP.
3 Write an echo program with client and concurrent
server using UDP.
4 Write a client and server program for chatting

5 Write a program to retrieve date and time using TCP.

6 Write a program to retrieve date and time using UDP.

7 Write an echo client and server program using Unix

domain stream socket
8 Write an echo client and server program using Unix
domain Datagram socket.
9 Write a client and server program to implement file
transfer.
10 Write a client and server program to implement the
remote command execution.
 EXPERIMENT 01

AIM : Write an echo program with client and iterative server using TCP.
Implementing the solution
1) Write a server (TCP) C Program that opens a listening socket and waits to serve client
2) Write a client (TCP) C Program that connects with the server program knowing IP
address and port number.
3) Get the input string from console on client and send it to server, server echoes back
that string to client.
3.3.1 Writing the source code

Client.c
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define RCVBUFSIZE 32
void DieWithError(char *errorMessage);
int main(int argc, char *argv[])
{
int sock;
struct sockaddr_in echoServAddr;
unsigned short echoServPort;
char *servIP;
char *echoString;
char echoBuffer[RCVBUFSIZE];
unsigned Int echoStringLen;
int bytesRcvd, totalBytesRcvd;
if ((argc < 3) || (argc > 4))
{
fprintf(stderr, "Usage: %s <Server IP> <Echo Word> [<Echo Port>]\n",
argv[0]);
exit(1);
}
servIP = argv[1];
echoString = argv[2];
if (argc == 4)
echoServPort = atoi(argv[3]);
else
echoServPort = 7;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
DieWithError("socket() failed");
memset(&echoServAddr, 0, sizeof(echoServAddr));
echoServAddr.sin_family = AF_INET;
echoServAddr.sin_addr.s_addr = inet_addr(servIP);
echoServAddr.sin_port = htons(echoServPort);
if (connect(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
DieWithError("connect() failed");
echoStringLen = strlen(echoString);
if (send(sock, echoString, echoStringLen, 0) != echoStringLen)
DieWithError("send() sent a different number of bytes than expected");
totalBytesRcvd = 0;
printf("Received: ");
while (totalBytesRcvd < echoStringLen)
 {
if ((bytesRcvd = recv(sock, echoBuffer, RCVBUFSIZE - 1, 0)) <= 0)
DieWithError("recv() failed or connection closed prematurely");
totalBytesRcvd += bytesRcvd; /* Keep tally of total bytes */
echoBuffer[bytesRcvd] = '\0';
printf(echoBuffer);
}
printf("\n");
close(sock);
exit(0);
}
void DieWithError(char *errorMessage)
{
perror(errorMessage);
exit(1);
}

Server.c
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define MAXPENDING 5
#define RCVBUFSIZE 32
void DieWithError(char *errorMessage);
void HandleTCPClient(int clntSocket);
int main(int argc, char *argv[])
{
int servSock;
int clntSock;
struct sockaddr_in echoServAddr;
struct sockaddr_in echoClntAddr;
unsigned short echoServPort;
unsigned int clntLen;
if (argc != 2)
{
fprintf(stderr, "Usage: %s <Server Port>\n", argv[0]);
exit(1);
}
echoServPort = atoi(argv[1]);
if ((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
DieWithError("socket() failed");
memset(&echoServAddr, 0, sizeof(echoServAddr));
echoServAddr.sin_family = AF_INET;
echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY);
echoServAddr.sin_port = htons(echoServPort);
if (bind(servSock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
DieWithError("bind() failed");
if (listen(servSock, MAXPENDING) < 0)
DieWithError("listen() failed");
for (;;)
{

clntLen = sizeof(echoClntAddr);
 if ((clntSock = accept(servSock, (struct sockaddr *) &echoClntAddr,
&clntLen)) < 0)
DieWithError("accept() failed");
printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));
//fork this process into a child and parent
processid = fork();
if (processid == 0){
close(servSock);
HandleTCPClient(clntSock);
}
close(clntSock);
}
}
void DieWithError(char *errorMessage)
{
perror(errorMessage);
exit(1);
}
void DieWithError(char *errorMessage);
void HandleTCPClient(int clntSocket)
{
char echoBuffer[RCVBUFSIZE];
int recvMsgSize;
while(1)
{
if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
DieWithError("recv() failed");
while (recvMsgSize > 0) /
{
if (send(clntSocket, echoBuffer, recvMsgSize, 0) != recvMsgSize)
DieWithError("send() failed");
if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
DieWithError("recv() failed");
}
}
close(clntSocket);
}
 EXPERIMENT 02
AIM : Write an echo program with client and concurrent server using TCP.

Server
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>
void handler_sigchld(int signum)
{
int status;
// Wait for all terminated children
// Loop is required as Unix signals are not queued by default.
while (waitpid(-1, &status, WNOHANG) > 0) {
}
}
int handle_terminated_children(void)
{
struct sigaction sigact;
sigact.sa_handler = handler_sigchld;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = SA_RESTART; // Make certain system calls restartable across signals
if (sigaction(SIGCHLD, &sigact, NULL)) {
return -1;
}
return 0;
}
#define SERVER_PORT 10060
#define LISTEN_BACKLOG 16
int server(void)
{
int listen_fd;
listen_fd = socket(AF_INET, SOCK_STREAM, 0); // TCP
if (listen_fd < 0) {
// errno is set appropriately
return -1;
}
struct sockaddr_in server_addr; // IPv4 socket address structure
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // Wildcard address; Network byte order
server_addr.sin_port = htons(SERVER_PORT);
if (bind(listen_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
// errno is set appropriately
return -2;
}
if (listen(listen_fd, LISTEN_BACKLOG) < 0) {
// errno is set appropriately
return -3;
}
 if (handle_terminated_children() < 0) {
return -4;
}
for (;;) {
int connection_fd;
struct sockaddr_in client_addr;
socklen_t client_addr_len;
client_addr_len = sizeof(client_addr);
connection_fd = accept(listen_fd, (struct sockaddr *) &client_addr, &client_addr_len);
if (connection_fd < 0) {
// errno is set appropriately
switch (errno) {
case EINTR:
// Interrupted by a signal. Restart the connection.
continue;
case EAGAIN:
case ENETDOWN:
case EPROTO:
case ENOPROTOOPT:
case EHOSTDOWN:
case ENONET:
case EHOSTUNREACH:
case EOPNOTSUPP:
case ENETUNREACH:
// Linux accept() passes already-pending network errors on the new

Client
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
ssize_t write_safe(int fd, const void *p, size_t n)
{
ssize_t num_written;
while (n > 0) {
num_written = write(fd, p, n);
if (num_written <= 0) {
if (errno == EINTR)
num_written = 0; // Try again
else
return -1;
}
n -= num_written;
p += num_written;
}
return num_written;
}
ssize_t read_safe(int fd, void *p, size_t n)
{
 size_t num_left;
ssize_t num_read;
num_left = n;
while (num_left > 0) {
num_read = read(fd, p, num_left);
if (num_read < 0) {
if (errno == EINTR)
num_read = 0; // Try again
else
return -1;
}
else if (num_read == 0) { // EOF
break;
}
num_left -= num_read;
p += num_read;
}
return n - num_left;
}
int client(const char *server_ip, int server_port)
{
int socket_fd;
socket_fd = socket(AF_INET, SOCK_STREAM, 0); // TCP
if (socket_fd < 0) {
// errno is set appropriately
return -1;
}
struct sockaddr_in server_addr; // IPv4 socket address structure
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
int status;
if ((status = inet_pton(AF_INET, server_ip, &server_addr.sin_addr)) < 0) {
// status < 0: Does not contain a valid address family
// status == 0: Source address is invalid in the specified address family
return -2;
}
server_addr.sin_port = htons(server_port);
if (connect(socket_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
// errno is set appropriately
return -3;
}
#define STR_MAX 100
// Get a string
char str[STR_MAX];
printf("Enter a few words: ");
if (fgets(str, STR_MAX, stdin)) {
// Send it to the server
if (write_safe(socket_fd, str, strlen(str)) < 0) {
// errno is set appropriately
return -4;
}
}
// Read from the server
ssize_t num_read;
if ((num_read = read_safe(socket_fd, str, STR_MAX)) < 0) {
// errno is set appropriately
 return -5;
}
// Display the result returned
printf("Echo: [%*s]\n", num_read, str);

return 0;
}

#define SERVER_PORT 10060

int main(int argc, char *argv[])
{
int retval;
retval = client("127.0.0.1", SERVER_PORT);
printf("retval => %d (%s)\n", retval, strerror(errno));
return 0;
}
 EXPERIMENT 03

AIM : Write an echo program with client and concurrent server using UDP.

PROGRAM:
UDP ECHO SERVER:main() function:
#include unp.h
main(int argc,char **argv)
{
int sockfd;
pid_t childfd;
socklen_t clilen;
struct sock_addr_in cliaddr,servaddr;
sockfd=Socket(AF_INET,SOCK_DGRAM,0);
bzero(&servadr;,sizeof(servaddr);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr,sin_port=htons(SERV_PORT);
bind(listenfd,(SA *) &servaddr;, sizeof(servaddr));
dg_echo(sockfd,(SA *) &cliaddre;,sizeof(cliaddr));
}
UDP ECHO SERVER:dg_echo function:
#include unp.h
void dg(int sockfd, SA *pcliaddr, sockeln_t clilen)
{int n;
socklen_t len;
char mesg[MAXLINE];
for( ; ; )
{len=clilen;
n=recvfrom(sockfd,mesg,MAXLINE,0,pcliaddr,&len;);
sendto(sockfd,mesg,n,0,pcliaddr,len);
}}
UDP ECHO CLIENT:main() function:
#include unp.h
int main(int argc, char **argv)
{int sockfd;
struct sockaddr_in servaddr;
if(argc!=2)
err_quit(usauge:UDPcli);
bzero(servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htons(SERV_PORT);
inet_pton(AF_INET,argv[1],&servaddr.sin;_addr);
sockfd=socket(AF_INET,SOCK_DGRAM,0);
dg_cli(stdin,sockfd,(SA *) &servaddr;,sizeof(servaddr));
exit(0);}
UDP ECHO CLIENT:dg_cli function:
#include unp.h
void dg_cli(FILE *fp,int sockfd,const SA *pervaddr,socklen_t servlen)
{Int n;
char sendline[MAXLINE],recvline[MAXLINE];
while(fgets(sendline,MAXLINE,fp)! = NULL)
{ sendto(sockfd,sendline,strlen(sendline),0,servaddr,servlen);
n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
recvline[n]=0;
fputs(recvline,stdout); } }
 EXPERIMWNT 04
AIM : Write a client and server program for chatting.
Client:
#include types.h><span>
#include in.h><span>
#include socket.h><span>
#include inet.h><span>
#define BUF_SIZE 500
#define PORT 3457
int main(void) {
int s;
int rtn;
char buff[BUF_SIZE];
struct sockaddr_in addr;
puts(Entering program);
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == -1) {
perror(Failed to get socket);
exit(EXIT_FAILURE);
}
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(PORT);
rtn = connect(s, (struct sockaddr * )&addr;, sizeof(addr) );
if (rtn == -1) {
perror(Failed to connect to server);
exit(EXIT_FAILURE);
}
for(;;) {
ssize_t len;
printf(speak );
fflush(stdout);
if (fgets(buff, BUF_SIZE, stdin) == NULL) {
fprintf(stderr, Failed to read inputn);
exit(EXIT_FAILURE);
}
len = write(s, buff, strlen(buff));
if (len == -1) {
perror(Failed to writen);
exit(EXIT_FAILURE);
}
len = read(s, buff, BUF_SIZE);
if (len < 0) {
fprintf(stderr, Failed to read network datan);
}
else if (len == 0) {
fprintf(stderr, No response data readn);
}
else {
buff[len] = ;
printf(server says : %sn, buff);
}
}
return 0;
}
Server
#include types.h><span>
#include in.h><span>
#include socket.h><span>
#include inet.h><span>
#define BUF_SIZE 500
#define PORT 3457
int main(int argc,char * argv[]) {
int s;
int rtn;
char buff[BUF_SIZE];
struct sockaddr_in addr;
int incoming_s;
socklen_t incoming_len;
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == -1) {
perror(Failed to get socket);
exit(EXIT_FAILURE);
}
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(PORT);
rtn = bind(s, (struct sockaddr*)&addr;, sizeof(addr));
if (rtn == -1) {
perror(Failed to get socket);
exit(EXIT_FAILURE); }
rtn = listen(s, 10);
if (rtn == -1) {
perror(Failed to listen on socket);
exit(EXIT_FAILURE); }
incoming_len = sizeof(addr);
memset(&addr;, 0, sizeof(addr));
incoming_s = accept(s, (struct sockaddr *)&addr;, &incoming;_len);
if (incoming_s == -1) {
perror(Failed to accept incoming connection);
exit(EXIT_FAILURE);
}
printf(Accepted incoming connectionn);
for (;;) {
ssize_t len = read(incoming_s, buff, BUF_SIZE);
if (len < 0) {
fprintf(stderr, Failed to read network datan);
}
else if (len == 0) { fprintf(stderr, No response data readn);
}
else {
buff[len] = ;
printf(client says : %s, buff);
printf(speak ); }
if (fgets(buff, BUF_SIZE, stdin) == NULL) {
fprintf(stderr, Failed to read inputn);
exit(EXIT_FAILURE);
}len = write(incoming_s, buff, strlen(buff));
if (len == -1) {
perror(Failed to writen);
exit(EXIT_FAILURE);}
}return 0; }
 EXPERIMENT 05

AIM: Write a program to retrieve date and time using TCP.

PROGRAM:
CLIENT:
import java.io.*;
import java.net.*;
{
public static void main(String args[])throws IOException
{
String rec;
String res;
try
{
Socket s=new Socket(127.0.0.1,8081);
BufferedReader brl=new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
do
{
rec=br.readLine();
pw.println(rec);
res=brl.readLine();
System.out.println(res);
}
while(!rec.equalsIgnoreCase(End));
}
catch(Exception e)
{
System.out.println(Error+e);
}
}
}
SERVER:
import java.io.*;
import java.net.*;
import java.util.*;
public class dtserver
{
public static void main(String args[])throws IOException
{
try
{
String com;
ServerSocket ss=new ServerSocket(8081);
Socket s=ss.accept();
System.out.println(Connected);
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
do
{
com=br.readLine();
System.out.println(com);
if(com.equalsIgnoreCase(Date))
{
GregorianCalendar c=new GregorianCalendar();
pw.println(c.get(Calendar.DATE)+/+(c.get(Calendar.MONTH)+/+(c.get(Calendar.YEAR))));
}
else if(com.equalsIgnoreCase(Time))
{
GregorianCalendar t=new GregorianCalendar();
t.setTime(new Date());
pw.println(t.get(Calendar.HOUR)+/+(t.get(Calendar.MINUTE)+/+
(t.get(Calendar.SECOND))));
}
else
{
pw.println(Wrong);
}
}
while(!com.equalsIgnoreCase(End));
}
catch(Exception e)
{
}
}
}
 EXPERIMENT 06

AIM : Write a program to retrieve date and time using UDP.

Client:
#include
#include
#include
#include
#include
#define SIZE 500
void usage(void);
int main(int argc, char **argv)
{
WSADATA w;
unsigned short port_number;
SOCKET sd;
int server_length;
char send_buffer[SIZE] = GET TIMErn;/
time_t current_time;
struct hostent *hp;
struct sockaddr_in server;
struct sockaddr_in client;
int a1, a2, a3, a4;
int b1, b2, b3, b4;
char host_name[256];
if (argc != 3 && argc != 4)
{
usage();
}
if (sscanf(argv[1], %d.%d.%d.%d, &a1;, &a2;, &a3;, &a4;) != 4)
{
usage();
}
if (sscanf(argv[2], %u, &port;_number) != 1)
{
usage();
}
if (argc == 4)
{
if (sscanf(argv[3], %d.%d.%d.%d, &b1;, &b2;, &b3;, &b4;) != 4)
{
usage();
}
}
if (WSAStartup(0x0101, &w;) != 0)
{
fprintf(stderr, Could not open Windows connection.n);
exit(0);
}
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd == INVALID_SOCKET)
{
fprintf(stderr, Could not create socket.n);
WSACleanup();
exit(0);
}
memset((void *)&server;, , sizeof(struct sockaddr_in));
server.sin_family = AF_INET;
server.sin_port = htons(port_number);
server.sin_addr.S_un.S_un_b.s_b1 = (unsigned char)a1;
server.sin_addr.S_un.S_un_b.s_b2 = (unsigned char)a2;
server.sin_addr.S_un.S_un_b.s_b3 = (unsigned char)a3;
server.sin_addr.S_un.S_un_b.s_b4 = (unsigned char)a4;
memset((void *)&client;, , sizeof(struct sockaddr_in));
client.sin_family = AF_INET;
client.sin_port = htons(0);
if (argc == 3)
{
gethostname(host_name, sizeof(host_name));
hp = gethostbyname(host_name);
if (hp == NULL)
{
fprintf(stderr, Could not get host name.n);
closesocket(sd);
WSACleanup();
exit(0);
}
client.sin_addr.S_un.S_un_b.s_b1 = hp->h_addr_list[0][0];
client.sin_addr.S_un.S_un_b.s_b2 = hp->h_addr_list[0][1];
client.sin_addr.S_un.S_un_b.s_b3 = hp->h_addr_list[0][2];
client.sin_addr.S_un.S_un_b.s_b4 = hp->h_addr_list[0][3];
}
else
{
client.sin_addr.S_un.S_un_b.s_b1 = (unsigned char)b1;
client.sin_addr.S_un.S_un_b.s_b2 = (unsigned char)b2;
client.sin_addr.S_un.S_un_b.s_b3 = (unsigned char)b3;
client.sin_addr.S_un.S_un_b.s_b4 = (unsigned char)b4;
}
if (bind(sd, (struct sockaddr *)&client;, sizeof(struct sockaddr_in)) == -1)
{
fprintf(stderr, Cannot bind address to socket.n);
closesocket(sd);
WSACleanup();
exit(0);
}
server_length = sizeof(struct sockaddr_in);
if (sendto(sd, send_buffer, (int)strlen(send_buffer) + 1, 0, (struct sockaddr *)&server;,
server_length) == -1)
{
fprintf(stderr, Error transmitting data.n);
closesocket(sd);
WSACleanup();
exit(0);
}
if (recvfrom(sd, (char *)t;_time, (int)sizeof(current_time), 0, (struct sockaddr *)&server;,
&server;_length) < 0)
{
fprintf(stderr, Error receiving data.n);
closesocket(sd);
WSACleanup();
exit(0);
}
printf(Current time: %s, ctime(t;_time));
closesocket(sd);
WSACleanup();
return 0;
}
void usage(void)
{
fprintf(stderr, Usage: timecli server_address port [client_address]n);
exit(0);
}
Server:
#include
#include
#include
#include
#include
#define BUFFER_SIZE 4096
void usage(void);
int main(int argc, char **argv)
{
WSADATA w;
unsigned short port_number;
int a1, a2, a3, a4;
int client_length;
int bytes_received;
SOCKET sd;
struct sockaddr_in server;
struct sockaddr_in client;
char buffer[BUFFER_SIZE];
struct hostent *hp;
char host_name[256];
time_t current_time;

if (argc == 2)
{

if (sscanf(argv[1], %u, &port;_number) != 1)

{
usage();
}
}
else if (argc == 3)
{

if (sscanf(argv[1], %d.%d.%d.%d, &a1;, &a2;, &a3;, &a4;) != 4)

{
usage();
}
if (sscanf(argv[2], %u, &port;_number) != 1)
{
usage();
}
}
else
{
usage();
}

if (WSAStartup(0x0101, &w;) != 0)
{
fprintf(stderr, Could not open Windows connection.n);
exit(0);
}

sd = socket(AF_INET, SOCK_DGRAM, 0);

if (sd == INVALID_SOCKET)
{
fprintf(stderr, Could not create socket.n);
WSACleanup();
exit(0);
}

memset((void *)&server;, , sizeof(struct sockaddr_in));

server.sin_family = AF_INET;
server.sin_port = htons(port_number);

if (argc == 2)
{

gethostname(host_name, sizeof(host_name));
hp = gethostbyname(host_name);

if (hp == NULL)
{
fprintf(stderr, Could not get host name.n);
closesocket(sd);
WSACleanup();
exit(0);
}
server.sin_addr.S_un.S_un_b.s_b1 = hp->h_addr_list[0][0];
server.sin_addr.S_un.S_un_b.s_b2 = hp->h_addr_list[0][1];
server.sin_addr.S_un.S_un_b.s_b3 = hp->h_addr_list[0][2];
server.sin_addr.S_un.S_un_b.s_b4 = hp->h_addr_list[0][3];
}
else
{
server.sin_addr.S_un.S_un_b.s_b1 = (unsigned char)a1;
server.sin_addr.S_un.S_un_b.s_b2 = (unsigned char)a2;
server.sin_addr.S_un.S_un_b.s_b3 = (unsigned char)a3;
server.sin_addr.S_un.S_un_b.s_b4 = (unsigned char)a4;
}

if (bind(sd, (struct sockaddr *)&server;, sizeof(struct sockaddr_in)) == -1)

{
fprintf(stderr, Could not bind name to socket.n);
closesocket(sd);
WSACleanup();
exit(0);
}
printf(Server running on %u.%u.%u.%un, (unsigned char)server.sin_addr.S_un.S_un_b.s_b1,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b2,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b3,
(unsigned char)server.sin_addr.S_un.S_un_b.s_b4);
printf(Press CTRL + C to quitn);
while (1)
{
client_length = (int)sizeof(struct sockaddr_in);

bytes_received = recvfrom(sd, buffer, BUFFER_SIZE, 0, (struct sockaddr *)&client;,

&client;_length);
if (bytes_received < 0)
{
fprintf(stderr, Could not receive datagram.n);
closesocket(sd);
WSACleanup();
exit(0);
}

if (strcmp(buffer, GET TIMErn) == 0)

{
current_time = time(NULL);

if (sendto(sd, (char *)t;_time, (int)sizeof(current_time), 0, (struct sockaddr *)&client;,

client_length) != (int)sizeof(current_time))
{
fprintf(stderr, Error sending datagram.n);
closesocket(sd);
WSACleanup();
exit(0);
}
}
}
closesocket(sd);
WSACleanup();
return 0;
}
void usage(void)
{
fprintf(stderr, timeserv [server_address] portn);
exit(0); }
 EXPERIMENT 07

AIM : Write an echo client and server program using Unix domain stream socket.
Client
#include
#include
#include
#include
#include
#include
#include types.h><span>
#include in.h><span>
#include socket.h><span>
#include inet.h><span>
#define PORT 3490 // the port client will be connecting to
#define MAXDATASIZE 100 // max number of bytes we can get at once
// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr);
}
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
int main(int argc, char *argv[])
{
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct addrinfo hints, *servinfo, *p;
int rv;
char s[INET6_ADDRSTRLEN];
if (argc != 2) {
fprintf(stderr,usage: client hostnamen);
exit(1);
}
memset(&hints;, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if ((rv = getaddrinfo(argv[1], PORT, &hints;, &servinfo;)) != 0) {
fprintf(stderr, getaddrinfo: %sn, gai_strerror(rv));
return 1;
}
// loop through all the results and connect to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror(client: socket);
continue;
}
if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror(client: connect);
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, client: failed to connectn);
return 2;
}
inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
s, sizeof s);
printf(client: connecting to %sn, s);
freeaddrinfo(servinfo); // all done with this structure
if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
perror(recv);
exit(1);
}
buf[numbytes] = ;
printf(client: received %sn,buf);
close(sockfd);
return 0;
}
Server
#include
#include
#include
#include
#include
#include types.h><span>
#include socket.h><span>
#include in.h><span>
#include
#include inet.h><span>
#include wait.h><span>
#include
#define PORT 3490 // the port users will be connecting to
#define BACKLOG 10 // how many pending connections queue will hold
void sigchld_handler(int s)
{
while(waitpid(-1, NULL, WNOHANG) > 0);
}
// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr); }
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
int main(void)
{
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct addrinfo hints, *servinfo, *p;
struct sockaddr_storage their_addr; // connectors address information
socklen_t sin_size;
struct sigaction sa;
int yes=1;
char s[INET6_ADDRSTRLEN];
int rv;
memset(&hints;, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP
if ((rv = getaddrinfo(NULL, PORT, &hints;, &servinfo;)) != 0) {
fprintf(stderr, getaddrinfo: %sn, gai_strerror(rv));
return 1; }
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror(server: socket);
continue; }
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes;,
sizeof(int)) == -1) {
perror(setsockopt);
exit(1); }
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror(server: bind);
continue;
}
break; }
if (p == NULL) {
fprintf(stderr, server: failed to bindn);
return 2;
}
freeaddrinfo(servinfo); // all done with this structure
if (listen(sockfd, BACKLOG) == -1) {
perror(listen);
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa;_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa;, NULL) == -1) {
perror(sigaction);
exit(1);
}
printf(server: waiting for connectionsn);
while(1) { // main accept() loop
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their;_addr, &sin;_size);
if (new_fd == -1) {
perror(accept);
continue; }
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their;_addr),
s, sizeof s);
printf(server: got connection from %sn, s);
if (!fork()) { // this is the child process
close(sockfd); // child doesnt need the listener
if (send(new_fd, Hello, world!, 13, 0) == -1)
perror(send);
close(new_fd);
exit(0);
} close(new_fd); // parent doesnt need this
}
return 0; }
 EXPERIMENT 08

AIM : Write an echo client and server program using Unix domain Datagram socket.
Listner
#include
#include
#include
#include
#include
#include types.h><span>
#include socket.h><span>
#include in.h><span>
#include inet.h><span>
#include
#define MYPORT 4950 // the port users will be connecting to
#define MAXBUFLEN 100
// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr);
}
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
int main(void)
{
int sockfd;
struct addrinfo hints, *servinfo, *p;
int rv;
int numbytes;
struct sockaddr_storage their_addr;
char buf[MAXBUFLEN];
socklen_t addr_len;
char s[INET6_ADDRSTRLEN];
memset(&hints;, 0, sizeof hints);
hints.ai_family = AF_UNSPEC; // set to AF_INET to force IPv4
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE; // use my IP
if ((rv = getaddrinfo(NULL, MYPORT, &hints;, &servinfo;)) != 0) {
fprintf(stderr, getaddrinfo: %sn, gai_strerror(rv));
return 1;
}
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror(listener: socket);
continue;
}
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror(listener: bind);
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, listener: failed to bind socketn);
return 2;
}
freeaddrinfo(servinfo);
printf(listener: waiting to recvfromn);
addr_len = sizeof their_addr;
if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0,
(struct sockaddr *)&their;_addr, &addr;_len)) == -1) {
perror(recvfrom);
exit(1);
}
printf(listener: got packet from %sn,
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their;_addr),
s, sizeof s));
printf(listener: packet is %d bytes longn, numbytes);
buf[numbytes] = ;
printf(listener: packet contains %sn, buf);
close(sockfd);
return 0;
}
Talker
#include
#include
#include
#include
#include
#include types.h><span>
#include socket.h><span>
#include in.h><span>
#include inet.h><span>
#include
#define SERVERPORT 4950 // the port users will be connecting to
int main(int argc, char *argv[])
{
int sockfd;
struct addrinfo hints, *servinfo, *p;
int rv;
int numbytes;
if (argc != 3) {
fprintf(stderr,usage: talker hostname messagen);
exit(1);
}
memset(&hints;, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ((rv = getaddrinfo(argv[1], SERVERPORT, &hints;, &servinfo;)) != 0) {
fprintf(stderr, getaddrinfo: %sn, gai_strerror(rv));
return 1;
}
// loop through all the results and make a socket
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror(talker: socket);
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, talker: failed to bind socketn);
return 2;
}
if ((numbytes = sendto(sockfd, argv[2], strlen(argv[2]), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror(talker: sendto);
exit(1);
}
freeaddrinfo(servinfo);
printf(talker: sent %d bytes to %sn, numbytes, argv[1]);
close(sockfd);
return 0;
}
 EXPERIMENT 09

AIM: Write a client and server program to implement file transfer

CLIENT:
import java.io.*;
import java.net.*;
import java.util.*;
public class ft1client
{
public static void main(String args[])
{
ry
{
DataInputStream dis=new DataInputStream(System.in);
System.out.println(Enter the file name :);
String f=dis.readLine();
File f1= new File(f);
FileReader fr=new FileReader(f1);
Socket s=new Socket(127.0.0.1,8081);
PrintWriter put=new PrintWriter(s.getOutputStream(),true);
put.println(f);
int c=0;
while((c=fr.read())!=-1)
put.println(c);
System.out.println(File content are transferred);
fr.close();
s.close();
}
catch(IOException e)
{
}
}
}

SERVER:
import java.io.*;
import java.net.*;
import java.util.*;
public class ft1server
{
public static void main(String args[])throws IOException
{
ServerSocket ss;
Socket s;
try
{
System.out.println(Waiting for client);
ss=new ServerSocket(8081);
s=ss.accept();
System.out.println(Connection established);
BufferedReader get=new BufferedReader(new InputStreamReader(s.getInputStream()));
String fname;
fname =get.readLine();
System.out.println(File name is : +fname);
File f=new File(fname);
FileWriter fw=new FileWriter(f);
String c;
while((c=get.readLine())!=null)
fw.write(Integer.parseInt(c));
System.out.println(Finished the content);
fw.close();
}
catch(IOException e)
{
}
}
}
 EXPERIMENT 10

AIM: Write a client and server program to implement the remote command execution.

PROGRAM:
CLIENT:
import java.io.*;
import java.net.*;
public class remclient
{
public static void main(String args[])throws IOException
{
try
{
Socket s=new Socket(127.0.0.1,8081);
string cmd;
DataInputStream in=new DataInputStream(System.in);
System.out.println(Enter the command to execute on server : );
cmd=in.readLine();
out.println(cmd);
}
catch(Exception e)
{
System.out.println(e);
}
}
}

SERVER:
import java.io.*;
import java.net.*;
public class remserver
{
public static void main(String args[])throws IOException
{
ServerSocket ss=new ServerSocket(8081);
Socket s=ss.accept();
String cmd;
BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
cmd=in.readLine();
try
{
Runtime r=Runtime.getRuntime();
Process a=r.exec(cmd);
System.out.println(Executing command : +cmd);
}
catch(Exception e)
{
System.out.println(Error+e);
}
s.close();
}
}