Académique Documents
Professionnel Documents
Culture Documents
Man(Help):-
syntax :- # man <command>
eg:- # man ls
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>
Eg:-
# vi 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
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>
Umask:- Set the default permission (system default permission 022) #umask
022
Filter commands:
More, Less, Sort, Wc, Head, Tail, Find
More:-file perusal filter for current viewing
syntax :- # more <filename>
eg:- # more test
Memory commands:
Df, Du
Network commands:
Ifconfig, Ping,
Who,netstat
#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 );
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
Output
#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
#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. */
Output
#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;
}
#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
#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
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
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;
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.
* */
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;
Server.c
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
return 0;
}
#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;
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);
if(listen(welcomeSocket,5)==0)
printf("Listening\n");
else
printf("Error\n");
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;
}
int main(){
int clientSocket, portNum, nBytes;
char buffer[1024];
struct sockaddr_in serverAddr;
socklen_t addr_size;
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);
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);
return 0;
}
Output
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
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
char sendline[MAXLINE],revline[MAXLINE];
int sockfd;
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));
write(sockfd,sendline,strlen(sendline));
read(sockfd,revline,MAXLINE);
printf("\n");
exit(0);
Output
// Driver code
int main()
{
struct sockaddr_in address;
int sock = 0, valread;
struct sockaddr_in serv_addr;
char str[100];
char buffer[1024] = { 0 };
int l = strlen(str);
printf("%s\n", str);
return 0;
}
// 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";
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
return 0;
}
Output
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);
//accept a connection
while(1)
{
printf("\n*****server waiting for new client connection:*****\n");
clientAddressLength=sizeof(clientAddress);
newsockfd=accept(sockfd,(struct
sockaddr*)&clientAddress,&clientAddressLength);
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
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);
n=strlen(msg1)+1;
send(sockfd,msg1,n,0);
n=recv(sockfd,msg2,MAXSZ,0);
return 0;
}
7. Write a program to implement time service using TCP client–server program.
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
externint errno;
s = connectTCP(host, service);
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define BUFSIZE 64
/*------------- * main - UDP client for TIME service that prints the result----------------- */
time_t now;
case 1:
host = "localhost";
break;
case 3:
service = argv[2];
host = argv[1];
break;
default:
exit(1);
s = connectUDP(host, service);
if (n < 0)
printf("%s", ctime(&now));
exit(0);