Information Commands: UNIX / LINUX COMMAND

Date, Cal, Man, Xclock, Ls, Exit, Poweroff, Reboot

Date :- Display date

# date
Cal:- Display Calendar
# cal
Xclock:- Display Clock #
xclock

Clear: - to clear the

screen # clear
Ls:- List of items

# ls <optional> <file / dir / path> Optional:

-a --all (Hidden files)
-d --directory
-l --use a long listing format
-r --reverse
-R --recursive
-s --size
-t sort by modification time
# ls * (* - All)
# ls ?( ? - one character)

Man(Help):-
syntax :- # man <command>
eg:- # man ls

Exit:-exit window or logout #

exit

Poweroff:- Shutdown system

#poweroff

Reboot :- Restart system #reboot

Directory commands:
mkdir, rmdir, cd, pwd

Mkdir:- create new Directory

Syntax:-
# mkdir <dir>
# mkdir -p <dir1 path> <dir2 path>…
Eg:-
# mkdir /ram
# mkdir -p /ram/ram/ /ram/raj/ /ram/laxman/

Rmdir:- Remove Empty Directory

Syntax:-
# rmdir <dir>
Eg:-
# rmdir /ram/laxman/

Cd:- Change Directory

Syntax:-
# cd <dir path>
# cd ..
# cd <dir name>
Eg:-
# cd /ram/raj/ #
cd ..
# cd raj

Pwd:- Present Working

Directory Syntax:-
# pwd
File manipulation commands:
Touch, cat, cp, mv, rm

Touch:- Its create empty files

Syntax:-
# touch <f1> <f2> <f3>...
# touch <filename> {1..100}
Eg:-
# touch f1 f2 f3 #
touch x{1..100}

Cat:- create new file, appending(added information into existed file) and
copy Syntax:-
# cat <f1> <f2> <f3>......
# cat > filename #
cat >> filename
 # cat f ilename > filename
# cat filename >> filename
Eg:-
# cat f1 f2 f3 #
cat > f1
# cat >> f1
# cat f1 > f2
# cat f1 f2 >> f3
Vi:- virtual editor
Syntax:-
# vi <filename>

esc + : wq! (save and quit)

esc + : q! (without save and quit)
esc + : x! (save)
esc + i (insert mode )
esc + yy (line copy)
esc + <num> + yy ( number of line
copy) esc + dd (delete line)
esc + <num> + dd (number of delete
line) esc + p (paste)
esc + D (delete end of the line from )
esc + o (new line)
esc + r (one character replace )
esc + R (replace mode
) esc + : %s/<old word>/<new
word>

Eg:-
# vi test.txt

Gedit :- Graphical Editor

syntax :-
# gedit <file name>
eg:-
# gedit test.txt

Cp(copy):- coping of file to file, file to directory, directory to directory

Syntax:-
# cp <old file name> <create file
name> # cp <filename> <dir>
# cp -r <dir> <dir>
Eg:-
# cp -r /ram/
/ram/raj/
Mv(move) :- Moving of file to file, file to directory, directory to directory and also
rename File or Directory
Syntax:-
# mv <old file name> <new file
name> # mv <old dir name> <new
dir name> # mv <file> <dir>
# mv <exsit dir name> <to dir path>
Eg:-
# mv f1 xyz
# mv /ram/ /ramu/
# mv xyz /ramu/
# mv /ramu/raj/ /ramu/ram/

Rm(remove) :- Removing of file, directory

Syntax:-
# rm <f1> <f2> <f3>...
# rm -i <f1> <f2>
<f3>... # rm -if <f1>
<f2> <f3>...
# rm -rf <f1> <dir1> <f2> <f3> ... #
rm <filename>{1..100}
Eg:-
# rm f1 f2
# rm -i f3...
# rm -if x1 x2 x3
# rm –rf x4 /ramu/ram/ x5
x6 # rm x{1..100}
User access & Identification commands:
Groupadd, Useradd, Passwd, Chown, Chgrp, Su, Userdel, Groupdel

Groupadd:- create new group

syntax:-
#groupadd <group name>
Eg:-
#groupadd dba

How find out group created or not #

cat /etc/group | grep dba

Useradd:- create new user

systax:- # useradd <user name>
eg:- # useradd user1

How find out user created or not

# cat /etc/group | grep user1
(or)
# id user1
Passwd :- Change and set password from existed user
systax:- #passwd <users name>
eg:- #passwd user1

Chown :- Change the ownership to File or Directory

syntax: - #chown <user name> <file/dir name>
eg:- #chown user1 test.txt

Chgrp:- Change the group ship to File or Directory

syntax: - # chgrp <group name> <file/dir name>
eg:- # chgrp dba test.txt

Su :- Switching User
syntax:- #su - <user name>( '-' means login)
eg:- # su – user1
$ exit
Userdel :- Delete existed user systax:-
#userdel <user name> eg:-
#userdel user1
Groupdel:-Delete existed group
 syntax:- #groupdel <group name>
Eg:- #groupdel dba

File /Directory permissions commands:

Chmod, Umask

Chmod :- Change the file permissions Read, Write, Execute in user, group, other levels
sysntax:-
#chmod 755 <file (or) dir name>
#chmod -R 755 <file/dir>
#chmod u=rwx, g=rwx,o=rwx <file/dir>
#chmod u=rw,g=rw,o=rw <file/dir>

#chmod 755 test.txt #chmod -R

755 <file/dir>
#chmod u=rwx, g=rwx,o=rwx test.txt #chmod
u=rw,g= r,o= r test.txt

Read=4 Write=2 Execute=1 Where

u=user, g=group, o=others
( -R means With contains)

Umask:- Set the default permission (system default permission 022) #umask
022

NOTE:- 777 – 022 = 755

Process management commands:

Ps, Grep, Kill

Ps:- Report a snapshot of the current processes. #

ps -ef

Grep:- print lines matching a pattern #

grep <search key>

Kill :- kill the session process #

kill -9 <process_id>

Filter commands:
More, Less, Sort, Wc, Head, Tail, Find
More:-file perusal filter for current viewing
syntax :- # more <filename>
eg:- # more test

Less :-opposite of more

syntax :- # less <filename>
eg:- # less test

Sort :-sort lines of text files

syntax :- #sort <filename>
eg :- #sort test

Wc :-print the number of lines, words, and bytes in files

syntax :- #wc <optional> <filename>
eg :- #wc test
#wc -c test (-c --total number of characters)
#wc -l test (-l --total number of lines)
#wc -w test (-w –total number of words)

Head:- output the first part of files

syntax :- #head <filename>
#head -<lines> <filename>
eg:- #head test
#head -20 test

Tail :-output the last part of files

syntax :- #tail <filename>

#tail -<lines> <filename>
eg:- #tail test #tail
-20 test

Find :-search for files in a directory hierarchy

syntax :- #find <path> -name <filename>
eg:- #find /root -name test

Memory commands:
Df, Du

Df- report file system disk space usage

# df
# df -h # df
-Th

Du:- estimate file space usage

syntax :- # du –sh <file dir>
eg:- # du -sh test /bin

Network commands:

Ifconfig, Ping,
Who,netstat

Ifconfig:-configure a network interface #

ifconfig eth0

Ping :- check vether the Connect to network hosts

#ping <IP Adderss/host name>

Who - show who is logged on

#who
#who am i
1. Write a program to create a socket and implement connect function.

#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#define PORT 8080
int main(int argc, char const *argv[])
{
int server_fd, new_socket, valread;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[1024] = {0};
char *hello = "Hello from server";
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
{
perror("socket failed");
exit(EXIT_FAILURE);
}
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,

&opt, sizeof(opt)))
{
perror("setsockopt");
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons( PORT );

if (bind(server_fd, (struct sockaddr *)&address,

sizeof(address))<0)
{
perror("bind failed");
exit(EXIT_FAILURE);
}
if (listen(server_fd, 3) < 0)
{
perror("listen");
exit(EXIT_FAILURE);
 }
if ((new_socket = accept(server_fd, (struct sockaddr *)&address,
(socklen_t*)&addrlen))<0)
{
perror("accept");
exit(EXIT_FAILURE);
}
valread = read( new_socket , buffer, 1024);
printf("%s\n",buffer );
send(new_socket , hello , strlen(hello) , 0 );
printf("Hello message sent\n");
return 0;
}

// Client side C/C++ program to demonstrate Socket programming

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#define PORT 8080

int main(int argc, char const *argv[])

{
struct sockaddr_in address;
int sock = 0, valread;
struct sockaddr_in serv_addr;
char *hello = "Hello from client";
char buffer[1024] = {0};
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}

memset(&serv_addr, '0', sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from text to binary form

if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
 if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\nConnection Failed \n");
return -1;
}
send(sock , hello , strlen(hello) , 0 );
printf("Hello message sent\n");
valread = read( sock , buffer, 1024);
printf("%s\n",buffer );
return 0;
}
Compiling:

gcc client.c -o client

gcc server.c -o server

Output

2. Write a program to get MAC address.

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <stdio.h>
#include <string.h>
void mac_eth0(unsigned char MAC_str[13])
{
#define HWADDR_len 6
int s,i;
struct ifreq ifr;
s = socket(AF_INET, SOCK_DGRAM, 0);
strcpy(ifr.ifr_name, "br-wlan");
ioctl(s, SIOCGIFHWADDR, &ifr);
for (i=0; i<HWADDR_len; i++)
sprintf(&MAC_str[i*2],"%02X",((unsigned char*)ifr.ifr_hwaddr.sa_data)[i]);
MAC_str[12]='\0';
}
int main(int argc, char *argv[])
{
unsigned char mac[13];
mac_eth0(mac);
puts(mac);
return 0;
}
output

3. Write a program to display hello world using signals.

#include<stdio.h>
#include<signal.h>
int main()
{
signal(SIGINT, handle_sigint);
while (1)
{
printf(“hello world\n”);
sleep(1);
}
return 0;
}
4 Write a program for socket pair system call using IPC.

/*
@(#)socketpair.c
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define DATA1 "In Xanadu, did Kublai Khan . . ."
#define DATA2 "A stately pleasure dome decree . . ."
/*
* This program creates a pair of connected sockets then forks and
* communicates over them. This is very similar to communication with pipes,
* however, socketpairs are two-way communications objects. Therefore I can
* send messages in both directions.
*/
int main()
{
int sockets[2], child;
char buf[BUFSIZ];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) < 0)
{
perror("opening stream socket pair");
exit(1);
}
/* Note: Execution order of parent/child is not guaranteed! Hence,
* order of data being sent/read is entirely undefined. Do not
* rely on any order, even if you repeatedly observe it to follow
* what you perceive as a pattern. */

if ((child = fork()) == -1)

perror("fork");
else if (child) { /* This is the parent. */
close(sockets[0]);
printf("Parent (%d) --> sending: %s\n", getpid(), DATA1);
if (write(sockets[1], DATA1, sizeof(DATA1)) < 0)
perror("writing stream message");
if (read(sockets[1], buf, BUFSIZ) < 0)
perror("reading stream message");
printf("Parent (%d) --> reading: %s\n", getpid(), buf);
close(sockets[1]);
} else { /* This is the child. */
close(sockets[1]);
printf("Child (%d) --> sending: %s\n", getpid(), DATA2);
if (write(sockets[0], DATA2, sizeof(DATA2)) < 0)
perror("writing stream message");
if (read(sockets[0], buf, BUFSIZ) < 0)
perror("reading stream message");
printf("Child (%d) --> reading: %s\n", getpid(), buf);
close(sockets[0]);
}
return 0;
 }

Output

5. Write a program to implement the sliding window protocol.

#include<stdio.h>
int main()
{
int w,i,f,frames[50];
printf("Enter window size: ");
scanf("%d",&w);
printf("\nEnter number of frames to transmit: ");
scanf("%d",&f);
printf("\nEnter %d frames: ",f);
for(i=1;i<=f;i++)
scanf("%d",&frames[i]);

printf("\nWith sliding window protocol the frames will be sent in the following manner (assuming
no corruption of frames)\n\n");

printf("After sending %d frames at each stage sender waits for acknowledgement sent by the
receiver\n\n",w);

for(i=1;i<=f;i++)
{
if(i%w==0)
 {
printf("%d\n",frames[i]);
printf("Acknowledgement of above frames sent is received by sender\n\n");
}
else
printf("%d ",frames[i]);
}

if(f%w!=0)
printf("\nAcknowledgement of above frames sent is received by sender\n");

return 0;
}

6. Write a program to identify the category of IP address for a given IP address.

#include <stdio.h>
#include <string.h>
void extractIpAddress(unsigned char *sourceString,short *ipAddress)
{
unsigned short len=0;
unsigned char oct[4]={0},cnt=0,cnt1=0,i,buf[5];
len=strlen(sourceString);
for(i=0;i<len;i++)
{
if(sourceString[i]!='.'){
buf[cnt++] =sourceString[i];
 }
if(sourceString[i]=='.' || i==len-1){
buf[cnt]='\0';
cnt=0;
oct[cnt1++]=atoi(buf);
}
}
ipAddress[0]=oct[0];
ipAddress[1]=oct[1];
ipAddress[2]=oct[2];
ipAddress[3]=oct[3];
}
int main()
{
unsigned char ip[20]={0};
short ipAddress[4];
printf("Enter IP Address (xxx.xxx.xxx.xxx format): ");
scanf("%s",ip);
extractIpAddress(ip,&ipAddress[0]);
printf("\nIp Address: %03d. %03d. %03d.
%03d\n",ipAddress[0],ipAddress[1],ipAddress[2],ipAddress[3]);
if(ipAddress[0]>=0 && ipAddress[0]<=127)
printf("Class A Ip Address.\n");
if(ipAddress[0]>127 && ipAddress[0]<191)
printf("Class B Ip Address.\n");
if(ipAddress[0]>191 && ipAddress[0]<224)
printf("Class C Ip Address.\n");
if(ipAddress[0]>224 && ipAddress[0]<=239)
printf("Class D Ip Address.\n");
if(ipAddress[0]>239)
printf("Class E Ip Address.\n");
return 0;
}

Output
7. Write a program to print details of DNS host.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
void checkHostName(int hostname)
{
if (hostname == -1)
{
perror("gethostname");
exit(1);
}
}
void checkHostEntry(struct hostent * hostentry)
{
if (hostentry == NULL)
{
perror("gethostbyname");
exit(1);
}
}
void checkIPbuffer(char *IPbuffer)
{
if (NULL == IPbuffer)
{
perror("inet_ntoa");
exit(1);
}
}

int main()
 {
char hostbuffer[256];
char *IPbuffer;
struct hostent *host_entry;
int hostname;
hostname = gethostname(hostbuffer, sizeof(hostbuffer));
checkHostName(hostname);
host_entry = gethostbyname(hostbuffer);
checkHostEntry(host_entry);
IPbuffer = inet_ntoa(*((struct in_addr*)
host_entry->h_addr_list[0]));
printf("Hostname: %s\n", hostbuffer);
printf("Host IP: %s", IPbuffer);
return 0;
}

Output

8.Write a program to implement listener and talker.

/******** listener.c – listens for incoming messages on port 5000 ********/

#include <stdio.h>

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MYPORT __________ // the port talker will be connecting to

#define MAXBUFLEN 100

int main(void) {
int sockfd;
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // talker's address information
int addr_len, numbytes;
char buf[MAXBUFLEN];
if ((sockfd = socket(________, ________, ________)) == -1) {//exit on error

perror("socket");

exit(1);

my_addr.sin_family = __________;
my_addr.sin_port = htons(________);
my_addr.sin_addr.s_addr = ______________; // automatically fill with my IP
memset(&(my_addr.sin_zero), 0, 8); // zero the rest of the struct
if (bind(___________, _________,___________) == -1) {//exit on error
perror("bind");
exit(1);
}

addr_len = _____________;
if ((numbytes=recvfrom(________,________,___________, ________,
____________, __________)) == -1) {//exit on error
perror("recvfrom");
exit(1);
}
printf("got packet from %s IP address\n",inet_ntoa(______________));
printf("packet is %d bytes long\n",___________);
buf[numbytes] = '\0';
printf("packet contains the message \"%s\"\n",_________);
close(_________);
return 0;
}
/***** talker.c reads input from command line and sends message to listener ******/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define LPORT _________ // the port listener is waiting on
int main(int argc, char *argv[]) {
int sockfd;
struct sockaddr_in their_addr; // listener's address information
int numbytes;
if (argc != 3) {
fprintf(stderr,"usage: talker hostname message\n");
exit(1);
}
if ((sockfd = socket(_______, _____________, _________)) == -1) {
perror("socket");
exit(1);
}
their_addr.sin_family = __________;
their_addr.sin_port = htons(___________);
inet_aton(________, ________); // fill the IP address in their_addr.sin_addr
memset(&(their_addr.sin_zero), '\0', 8); // zero the rest of the struct
if ((numbytes=sendto(_______, _________, __________, 0,
_____________, ______________)) == -1) { //exit on error
perror("sendto");
exit(1);
}
printf("sent %d bytes to %s IP address \n", _________, inet_ntoa(_________));
close(_______);
return 0;
}
Output

1. Write a program to implement TCP echo using client–server program

Client.c

#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main() {
const char* server_name = "localhost";
const int server_port = 8877;

struct sockaddr_in server_address;

memset(&server_address, 0, sizeof(server_address));
server_address.sin_family = AF_INET;
int sock;
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
printf("could not create socket\n");
return 1;
}

if (connect(sock, (struct sockaddr*)&server_address,

sizeof(server_address)) < 0) {
 printf("could not connect to server\n");
return 1;
}

const char* data_to_send = "Gangadhar Hi Shaktimaan hai";

send(sock, data_to_send, strlen(data_to_send), 0);
int n = 0;
int len = 0, maxlen = 100;
char buffer[maxlen];
char* pbuffer = buffer;
while ((n = recv(sock, pbuffer, maxlen, 0)) > 0) {
pbuffer += n;
maxlen -= n;
len += n;

buffer[len] = '\0';
printf("received: '%s'\n", buffer);
}
close(sock);
return 0;
}

Server.c
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
/**
* TCP Uses 2 types of sockets, the connection socket and the listen socket.
* The Goal is to separate the connection phase from the data exchange phase.
* */

int main(int argc, char *argv[]) {

int SERVER_PORT = 8877;
struct sockaddr_in server_address;
memset(&server_address, 0, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
int listen_sock;
if ((listen_sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
printf("could not create listen socket\n");
return 1;
}
if ((bind(listen_sock, (struct sockaddr *)&server_address,
sizeof(server_address))) < 0) {
printf("could not bind socket\n");
return 1;
}
int wait_size = 16;
if (listen(listen_sock, wait_size) < 0) {
printf("could not open socket for listening\n");
return 1;
}
struct sockaddr_in client_address;
int client_address_len = 0;
while (true) {
// open a new socket to transmit data per connection
int sock;
if ((sock =
accept(listen_sock, (struct sockaddr *)&client_address,
&client_address_len)) < 0) {
printf("could not open a socket to accept data\n");
return 1;
}
int n = 0;
int len = 0, maxlen = 100;
char buffer[maxlen];
char *pbuffer = buffer;

printf("client connected with ip address: %s\n",

inet_ntoa(client_address.sin_addr));
while ((n = recv(sock, pbuffer, maxlen, 0)) > 0) {
pbuffer += n;
maxlen -= n;
len += n;
printf("received: '%s'\n", buffer);
send(sock, buffer, len, 0);
 }
close(sock);
}
close(listen_sock);
return 0;
}
Output

2. Write a program to implement UDP echo using client–server program.

Client.c
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int main() {
const char* server_name = "localhost";
const int server_port = 8877;

struct sockaddr_in server_address;

memset(&server_address, 0, sizeof(server_address));
server_address.sin_family = AF_INET;
// open socket
int sock;
if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
printf("could not create socket\n");
return 1;
 }
const char* data_to_send = "Gangadhar Hi Shaktimaan hai";
int len =
sendto(sock, data_to_send, strlen(data_to_send), 0,
(struct sockaddr*)&server_address, sizeof(server_address));
char buffer[100];
recvfrom(sock, buffer, len, 0, NULL, NULL);
buffer[len] = '\0';
printf("recieved: '%s'\n", buffer);
close(sock);
return 0;
}

Server.c

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {

int SERVER_PORT = 8877;
struct sockaddr_in server_address;
memset(&server_address, 0, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
int sock;
if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
printf("could not create socket\n");
return 1;
}
if ((bind(sock, (struct sockaddr *)&server_address,
sizeof(server_address))) < 0) {
printf("could not bind socket\n");
return 1;
}
struct sockaddr_in client_address;
int client_address_len = 0;
 while (true) {
char buffer[500];
int len = recvfrom(sock, buffer, sizeof(buffer), 0,
(struct sockaddr *)&client_address,
&client_address_len);
buffer[len] = '\0';
printf("received: '%s' from client %s\n", buffer,
inet_ntoa(client_address.sin_addr));
sendto(sock, buffer, len, 0, (struct sockaddr *)&client_address,
sizeof(client_address));
}

return 0;
}

3. Write a UDP client–server program to convert lowercase letters to uppercase letters.

/******************* SERVER CODE *****************/

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdlib.h>

int main(){
int welcomeSocket, newSocket, portNum, clientLen, nBytes;
char buffer[1024];
struct sockaddr_in serverAddr;
struct sockaddr_storage serverStorage;
socklen_t addr_size;
int i;

welcomeSocket = socket(PF_INET, SOCK_STREAM, 0);

portNum = 7891;

serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(portNum);
 serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);

bind(welcomeSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr));

if(listen(welcomeSocket,5)==0)
printf("Listening\n");
else
printf("Error\n");

addr_size = sizeof serverStorage;

while(1){
newSocket = accept(welcomeSocket, (struct sockaddr *) &serverStorage,
&addr_size);
/*fork a child process to handle the new connection*/
if(!fork()){
nBytes = 1;
/*loop while connection is live*/
while(nBytes!=0){
nBytes = recv(newSocket,buffer,1024,0);

for (i=0;i<nBytes-1;i++){
buffer[i] = toupper(buffer[i]);
}

send(newSocket,buffer,nBytes,0);
}
close(newSocket);
exit(0);
}
/*if parent, close the socket and go back to listening new requests*/
else{
close(newSocket);
}
}

return 0;
}

/******************* CLIENT CODE *****************/

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

int main(){
int clientSocket, portNum, nBytes;
char buffer[1024];
struct sockaddr_in serverAddr;
socklen_t addr_size;

clientSocket = socket(PF_INET, SOCK_STREAM, 0);

portNum = 7891;

serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(portNum);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);

addr_size = sizeof serverAddr;

connect(clientSocket, (struct sockaddr *) &serverAddr, addr_size);

while(1){
printf("Type a sentence to send to server:\n");
fgets(buffer,1024,stdin);
printf("You typed: %s",buffer);

nBytes = strlen(buffer) + 1;

send(clientSocket,buffer,nBytes,0);

recv(clientSocket, buffer, 1024, 0);

printf("Received from server: %s\n\n",buffer);

}

return 0;
}
 Output

4. Write a TCP client–server program to convert a given string into reverse.

Server Program

#include<string.h>

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<sys/socket.h>

#include<sys/types.h>

#define MAXLINE 20

#define SERV_PORT 5777

main(int argc,char *argv)

int i,j;

ssize_t n;

char line[MAXLINE];

char revline[MAXLINE];

int listenfd,connfd,clilen;
struct sockaddr_in servaddr,cliaddr;

listenfd=socket(AF_INET,SOCK_STREAM,0);

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_family=AF_INET; servaddr.sin_port=htons(SERV_PORT);

bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

listen(listenfd,1);

for( ; ; )

clilen=sizeof(cliaddr);

connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&clilen);

printf("connect to client");

while(1)

if((n=read(connfd,line,MAXLINE))==0)

break;

line[n-1]='\0';

j=0;

for(i=n-2;i>=0;i--)

revline[j++]=line[i];

revline[j]='\0';

write(connfd,revline,n);

}
}

Client Program

#include<string.h>

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<sys/types.h>

#define MAXLINE 20

#define SERV_PORT 5777

main(int argc,char *argv)

char sendline[MAXLINE],revline[MAXLINE];

int sockfd;

struct sockaddr_in servaddr;

sockfd=socket(AF_INET,SOCK_STREAM,0);

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_family=AF_INET;

servaddr.sin_port=ntohs(SERV_PORT);

connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

printf("\n enter the data to be send");

while(fgets(sendline,MAXLINE,stdin)!=NULL)

write(sockfd,sendline,strlen(sendline));

printf("\n line send");

read(sockfd,revline,MAXLINE);

printf("\n reverse of the given sentence is : %s",revline);

printf("\n");

exit(0);

Output

5. Write a UDP client–server program to convert a given string into reverse.

// C client code to send string to reverse
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

#define PORT 8090

// Driver code
int main()
{
struct sockaddr_in address;
int sock = 0, valread;
struct sockaddr_in serv_addr;
char str[100];

printf("\nInput the string:");

scanf("%[^\n]s", str);

char buffer[1024] = { 0 };

// Creating socket file descriptor

if ((sock = socket(AF_INET,
SOCK_STREAM, 0))
< 0) {
printf("\n Socket creation error \n");
return -1;
}

memset(&serv_addr, '0', sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from

// text to binary form 127.0.0.1 is local
// host IP address, this address should be
// your system local host IP address
if (inet_pton(AF_INET, "127.0.0.1",
&serv_addr.sin_addr)
<= 0) {
printf("\nAddress not supported \n");
return -1;
}

// connect the socket

if (connect(sock, (struct sockaddr*)&serv_addr,
sizeof(serv_addr))
< 0) {
printf("\nConnection Failed \n");
return -1;
 }

int l = strlen(str);

// send string to server side

send(sock, str, sizeof(str), 0);

// read string sent by server

valread = read(sock, str, l);

printf("%s\n", str);

return 0;
}

// Server C code to reverse a

// string by sent from client
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

#define PORT 8090

// Driver code
int main()
{
int server_fd, new_socket, valread;
struct sockaddr_in address;
char str[100];
int addrlen = sizeof(address);
char buffer[1024] = { 0 };
char* hello = "Hello from server";

// Creating socket file descriptor

if ((server_fd = socket(AF_INET,
SOCK_STREAM, 0)) == 0) {
 perror("socket failed");
exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// Forcefully attaching socket to

// the port 8090
if (bind(server_fd, (struct sockaddr*)&address,
sizeof(address)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}

// puts the server socket in passive mode

if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
if ((new_socket = accept(server_fd,
(struct sockaddr*)&address,
(socklen_t*)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}

// read string send by client

valread = read(new_socket, str,
sizeof(str));
int i, j, temp;
int l = strlen(str);

printf("\nString sent by client:%s\n", str);

// loop to reverse the string

for (i = 0, j = l - 1; i < j; i++, j--) {
temp = str[i];
str[i] = str[j];
 str[j] = temp;
}

// send reversed string to client

// by send system call
send(new_socket, str, sizeof(str), 0);
printf("\nModified string sent to client\n");

return 0;
}

Output

6. Write a program to implement TCP iterative client–server program.

//TCP SERVER Iterative: only one client is handled

#include<stdio.h>
#include<sys/types.h>//socket
#include<sys/socket.h>//socket
#include<string.h>//memset
#include<stdlib.h>//sizeof
#include<netinet/in.h>//INADDR_ANY

#define PORT 8000

#define MAXSZ 100
int main()
{
int sockfd;//to create socket
int newsockfd;//to accept connection
struct sockaddr_in serverAddress;//server receive on this address
struct sockaddr_in clientAddress;//server sends to client on this address

int n;
char msg[MAXSZ];
int clientAddressLength;

//create socket
sockfd=socket(AF_INET,SOCK_STREAM,0);
//initialize the socket addresses
memset(&serverAddress,0,sizeof(serverAddress));
serverAddress.sin_family=AF_INET;
serverAddress.sin_addr.s_addr=htonl(INADDR_ANY);
serverAddress.sin_port=htons(PORT);

//bind the socket with the server address and port

bind(sockfd,(struct sockaddr *)&serverAddress, sizeof(serverAddress));

//listen for connection from client

listen(sockfd,5);

//accept a connection
while(1)
{
printf("\n*****server waiting for new client connection:*****\n");
clientAddressLength=sizeof(clientAddress);
newsockfd=accept(sockfd,(struct
sockaddr*)&clientAddress,&clientAddressLength);

//rceive from client

while(1)
{
n=recv(newsockfd,msg,MAXSZ,0);
if(n==0)
{
close(newsockfd);
break;
}
msg[n]=0;
send(newsockfd,msg,n,0);
 printf("Receive and set:%s\n",msg);
}//close interior while
}//close exterior while

return 0;
}

Output

/**********Client*************/
//CLIENT ITERATIVE

#include<stdio.h>
#include<sys/types.h>//socket
#include<sys/socket.h>//socket
#include<string.h>//memset
#include<stdlib.h>//sizeof
#include<netinet/in.h>//INADDR_ANY

#define PORT 8000

#define SERVER_IP "127.0.0.1"
#define MAXSZ 100
int main()
{
int sockfd;//to create socket
struct sockaddr_in serverAddress;//client will connect on this

int n;
char msg1[MAXSZ];
char msg2[MAXSZ];

//create socket
sockfd=socket(AF_INET,SOCK_STREAM,0);
//initialize the socket addresses
memset(&serverAddress,0,sizeof(serverAddress));
serverAddress.sin_family=AF_INET;
serverAddress.sin_addr.s_addr=inet_addr(SERVER_IP);
serverAddress.sin_port=htons(PORT);

//client connect to server on port

connect(sockfd,(struct sockaddr *)&serverAddress,sizeof(serverAddress));
//send to sever and receive from server
while(1)
{
printf("\nEnter message to send to server:\n");
fgets(msg1,MAXSZ,stdin);
if(msg1[0]=='#')
break;

n=strlen(msg1)+1;
send(sockfd,msg1,n,0);

n=recv(sockfd,msg2,MAXSZ,0);

printf("Receive message from server::%s\n",msg2);

}

return 0;
}
7. Write a program to implement time service using TCP client–server program.

/* TCPdaytime.c - TCPdaytime, main */

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

externint errno;

int TCPdaytime(constchar *host, constchar *service);

int errexit(constchar *format, ...);
int connectTCP(constchar *host, constchar *service);

#define LINELEN 128

/*------------- * main - TCP client for DAYTIME ser------------------------------------ */

Int main(int argc, char *argv[])
{
 char *host = "localhost";
char *service = "daytime";
switch (argc) {
case 1:
host = "localhost";
break;
case 3:
service = argv[2];
/* FALL THROUGH */case 2:
host = argv[1];
break;
default:
fprintf(stderr, "usage: TCPdaytime [host [port]]\n");
exit(1);
}
TCPdaytime(host, service);
exit(0);
}

/*----------TCPdaytime - invoke Daytime on specified host and print results

*------------------------------------------------------------------------ */
TCPdaytime(constchar *host, constchar *service)
{
char buf[LINELEN+1]; /* buffer for one line of text */int s, n; /*
socket, read count */

s = connectTCP(host, service);

while( (n = read(s, buf, LINELEN)) > 0) {

buf[n] = '\0'; /* ensure null-terminated */
(void) fputs( buf, stdout );
}
}

8. Write a program to implement time service using UDP client–server program.

#include <sys/types.h>

#include <unistd.h>
#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#define BUFSIZE 64

#define UNIXEPOCH 2208988800 /* UNIX epoch, in UCT secs */#define MSG

"what time is it?\n"externint errno;

int connectUDP(constchar *host, constchar *service);

int errexit(constchar *format, ...);

/*------------- * main - UDP client for TIME service that prints the result----------------- */

Int main(int argc, char *argv[])

char *host = "localhost";

char *service = "time";

time_t now;

int s, n; /* socket descriptor, read count*/switch (argc) {

case 1:

host = "localhost";

break;

case 3:

service = argv[2];

/* FALL THROUGH */case 2:

host = argv[1];

break;
 default:

fprintf(stderr, "usage: UDPtime [host [port]]\n");

exit(1);

s = connectUDP(host, service);

(void) write(s, MSG, strlen(MSG));

/* Read the time */

n = read(s, (char *)&now, sizeof(now));

if (n < 0)

errexit("read failed: %s\n", strerror(errno));

now = ntohl((u_long)now); /* put in host byte order */

now -= UNIXEPOCH; /* convert UCT to UNIX epoch */

printf("%s", ctime(&now));

exit(0);