Friday, December 15, 2017

HTML

HTML ppt
HTML pdf
Posted by at No comments:

Wednesday, November 22, 2017

LP Unit I Notes

LP UNIT I Notes
Posted by at 1 comment:

LP UNIT III,IV, and V Programs



Unit – III Process

Programs

1.    Write a C program to create a child process and allow the parent to display “parent” and the child to display “child” on the screen.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int pid;
int p[2];
int q[2];
int a;
int b;
a = pipe(p);
if(a == -1)
{
fprintf(stderr, "Pipe Failed.\n");
return EXIT_FAILURE;
}
b = pipe(q);
if(b == -1)
{
fprintf(stderr, "Pipe Failed.\n");
return EXIT_FAILURE;
}
pid = fork();
switch(pid){
case -1: perror("main: fork");
exit(1);
case 0: printf("Child process ID: %d\n", pid); break;
default: printf("Parent process ID: %d\n", pid); break;
}
getchar();
return 0;
}

 2.    Write a C program to create a Zombie process.
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main ()
{
pid_t child_pid;
child_pid = fork ();
if (child_pid > 0) {
sleep (60);
} else {
exit (0);
}
return 0;
}
3.    Write a C program that illustrates how an orphan is created.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
pid_t i;
i=fork();
if (i==0)
{
while (1)
{
printf("child process pid = %d, ppid=%d\n",(int)getpid(), (int)getppid());
sleep(3);
} }
else
{
printf("parent has finished");
}
return 0;

Unit –IV IPC
PIPE and FIFO
1.    Write a C program that illustrates how to execute two commands concurrently with a command pipe. Eg. ls-l|sort.

#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
int fd[2],pid,k;
k=pipe(fd);
if(k==-1)
{
perror("pipe");
exit(1);
}
pid=fork();
if(pid==0)
{
close(fd[0]);
dup2(fd[1],1);
close(fd[1]);
execlp(argv[1],argv[1],NULL);
perror("execl");
}
else
{
wait(2);
close(fd[1]);
dup2(fd[0],0);
close(fd[0]);
execlp(argv[2],argv[2],NULL);
perror("execl");
}
}

 2.    Write a C program that illustrate communication between two unrelated processes using named pipe (FIFO file).
reader.c
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#define MAX_BUF 1024
int main()
{
int fd;
char * myfifo = "/tmp/myfifo";
char buf[MAX_BUF];
fd = open(myfifo, O_RDONLY);
read(fd, buf, MAX_BUF);
printf("Received: %s\n", buf);
close(fd);
return 0;
}
writer.c
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
int fd;
char * myfifo = "/tmp/myfifo";
mkfifo(myfifo, 0666);
fd = open(myfifo, O_WRONLY);
write(fd, "Hi", sizeof("Hi"));
close(fd);
unlink(myfifo);
return 0;
}

 3.    Write a C program in which a parent writes a message to a pipe and child reads the message.

#include <stdio.h>
#define READ 0
/* The index of the “read” end of the pipe */
#define WRITE 1
/* The index of the “write” end of the pipe */
char * phrase = "Hello welcome to CSE, SRITW, Warangal";
main ()
{
int fd[2], bytesRead;
char message [100]; /* Parent process’s message buffer */
pipe ( fd ); /*Create an unnamed pipe*/
if ( fork ( ) == 0 ) /* Child Writer */
{
close (fd[READ]); /* Close unused end*/
write (fd[WRITE], phrase,strlen ( phrase) +1); /* include NULL*/
close (fd[WRITE]); /* Close used end*/
}
else /* Parent Reader */
{
close (fd[WRITE]); /* Close unused end*/ bytesRead = read ( fd[READ], message, 100);
printf ( "Read %d bytes: %s\n", bytesRead, message);
close ( fd[READ]); /* Close used end */
}
}


Message Queue

send.c
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
main()
{
int qid,len,i;
char s[15];
struct
{
long mtype;
char mtext[15];
}
message,buff;
qid=msgget((key_t)10,IPC_CREAT|0666);
if(qid==-1)
{
perror("message queue create failed");
exit(1);
}
for(i=1;i<=3;i++)
{
printf("Enter the message to send\n");
scanf("%s",s);
strcpy(message.mtext,s);
message.mtype=i;
len=strlen(message.mtext);
if(msgsnd(qid,&message,len+1,0)==-1)
{
perror("message failed\n");
exit(1);
} } }

receive.c

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
main()
{
int qid,len,i;
char s[15];
struct
{
long mtype;
char mtext[15];
}buff;
qid=msgget((key_t)10,IPC_CREAT|0666);
if(qid==-1)
{
perror("message queue create failed");
exit(0);
}
for(i=1;i<=3;i++)
{
if(msgrcv(qid,&buff,15,i,0)==-1)
{
perror("message failed\n");
exit(0);
}
printf("Message received from sender is %s\n",buff.mtext);
}
}}

UNIT - V
Shared Memory
#include<stdio.h>
     #include<string.h>
     #include<sys/ipc.h>
     #include<sys/types.h>
     #include<sys/shm.h>
     #define SIZE 5*1024
     main()
     {
     char *ptr;
     int shmid,pid,n;
     shmid=shmget((key_t)10,30,IPC_CREAT|0666);
     ptr=(char *)shmat(shmid,(char *)0,0);
     pid=fork();
     if(pid==0)
     {
     n=read(0,ptr,SIZE);
     ptr[n]='\0';
     }    else      {
     wait(0)   ;
     printf("parent read from shared memory\n");
     write(1,ptr,strlen(ptr));
     }
     }
Semaphore
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<unistd.h>
#define num_loops 2
int main(int argc,char* argv[])
{
int sem_set_id;
int child_pid,i,sem_val;
struct sembuf sem_op;
int rc;
struct timespec delay;
clrscr();
sem_set_id=semget(ipc_private,2,0600);
if(sem_set_id==-1)
{
perror(“main:semget”);
exit(1);
}
printf(“semaphore set created,semaphore setid‘%d’\n ”,
sem_set_id);
child_pid=fork();
switch(child_pid)
{
case -1:
perror(“fork”);
exit(1);
case 0:
for(i=0;i<num_loops;i++)
{
sem_op.sem_num=0;
sem_op.sem_op=-1;
sem_op.sem_flg=0;
semop(sem_set_id,&sem_op,1);
printf(“producer:’%d’\n”,i);
fflush(stdout);
}
break;
default:
for(i=0;i<num_loops;i++){
printf(“consumer:’%d’\n”,i);
fflush(stdout);
sem_op.sem_num=0;
sem_op.sem_op=1;
sem_op.sem_flg=0;
semop(sem_set_id,&sem_op,1);
if(rand()>3*(rano_max14)){
delay.tv_sec=0;
delay.tv_nsec=10;
nanosleep(&delay,null);
}}
break;
}return 0;}

Sockets with UNIX domain
Client:
               #include <stdio.h>
      #include <sys/socket.h>
      #include <sys/un.h>
      #include <unistd.h>
      #include <string.h>
      int main(void)
      {
       struct sockaddr_un address;
       int  socket_fd, nbytes;
       char buffer[256];
       socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
       if(socket_fd < 0)
       {
        printf("socket() failed\n");
        return 1;
       } /* start with a clean address structure */
       memset(&address, 0, sizeof(struct sockaddr_un)); 
       address.sun_family = AF_UNIX;
       snprintf(address.sun_path, UNIX_PATH_MAX, "./demo_socket");
       if(connect(socket_fd, (struct sockaddr *) &address,  sizeof(struct sockaddr_un)) != 0)
       {
        printf("connect() failed\n");
        return 1;
       }
       nbytes = snprintf(buffer, 256, "hello from a client");
       write(socket_fd, buffer, nbytes);
       nbytes = read(socket_fd, buffer, 256);
       buffer[nbytes] = 0;
       printf("MESSAGE FROM SERVER: %s\n", buffer);
       close(socket_fd);
       return 0;
      }

Server:
               #include <stdio.h>
      #include <sys/socket.h>
      #include <sys/un.h>
      #include <sys/types.h>
      #include <unistd.h>
      #include <string.h>
      int connection_handler(int connection_fd)
      {
       int nbytes;
       char buffer[256];
       nbytes = read(connection_fd, buffer, 256);
       buffer[nbytes] = 0;
       printf("MESSAGE FROM CLIENT: %s\n", buffer);
       nbytes = snprintf(buffer, 256, "hello from the server");
       write(connection_fd, buffer, nbytes); 
       close(connection_fd);
       return 0;
      }
      int main(void)
      {
       struct sockaddr_un address;
       int socket_fd, connection_fd;
       socklen_t address_length;
       pid_t child; 
       socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
       if(socket_fd < 0)
       {
        printf("socket() failed\n");
        return 1;
       } 
       unlink("./demo_socket");       /* start with a clean address structure */
       memset(&address, 0, sizeof(struct sockaddr_un));
       address.sun_family = AF_UNIX;
       snprintf(address.sun_path, UNIX_PATH_MAX, "./demo_socket");
       if(bind(socket_fd,  (struct sockaddr *) &address,  sizeof(struct sockaddr_un)) != 0)
       {
        printf("bind() failed\n");
        return 1;
       }
       if(listen(socket_fd, 5) != 0)
       {
        printf("listen() failed\n");
        return 1;
       }
       while((connection_fd = accept(socket_fd, (struct sockaddr *) &address,   &address_length)) > -1)
       {
        child = fork();
        if(child == 0)
        {  /* now inside newly created connection handling process */
         return connection_handler(connection_fd);
        }/* still inside server process */
        close(connection_fd);
       }
       close(socket_fd);
       unlink("./demo_socket");
       return 0;
      }

Sockets with INTERNET domain
Client:
               #include <stdio.h>
      #include <sys/socket.h>
      #include <sys/un.h>
      #include <unistd.h>
      #include <string.h>
      int main(void)
      {
       struct sockaddr_un address;
       int  socket_fd, nbytes;
       char buffer[256];
       socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
       if(socket_fd < 0)
       {
        printf("socket() failed\n");
        return 1;
       } /* start with a clean address structure */
       memset(&address, 0, sizeof(struct sockaddr_un)); 
       address.sun_family = AF_UNIX;
       snprintf(address.sun_path, UNIX_PATH_MAX, "./demo_socket");
       if(connect(socket_fd, (struct sockaddr *) &address,  sizeof(struct sockaddr_un)) != 0)
       {
        printf("connect() failed\n");
        return 1;
       }
       nbytes = snprintf(buffer, 256, "hello from a client");
       write(socket_fd, buffer, nbytes);
       nbytes = read(socket_fd, buffer, 256);
       buffer[nbytes] = 0;
       printf("MESSAGE FROM SERVER: %s\n", buffer);
       close(socket_fd);
       return 0;
      }

Server:
               #include <stdio.h>
      #include <sys/socket.h>
      #include <sys/un.h>
      #include <sys/types.h>
      #include <unistd.h>
      #include <string.h>
      int connection_handler(int connection_fd)
      {
       int nbytes;
       char buffer[256];
       nbytes = read(connection_fd, buffer, 256);
       buffer[nbytes] = 0;
       printf("MESSAGE FROM CLIENT: %s\n", buffer);
       nbytes = snprintf(buffer, 256, "hello from the server");
       write(connection_fd, buffer, nbytes); 
       close(connection_fd);
       return 0;
      }
      int main(void)
      {
       struct sockaddr_un address;
       int socket_fd, connection_fd;
       socklen_t address_length;
       pid_t child; 
       socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
       if(socket_fd < 0)
       {
        printf("socket() failed\n");
        return 1;
       } 
       unlink("./demo_socket");       /* start with a clean address structure */
       memset(&address, 0, sizeof(struct sockaddr_un));
       address.sun_family = AF_UNIX;
       snprintf(address.sun_path, UNIX_PATH_MAX, "./demo_socket");
       if(bind(socket_fd,  (struct sockaddr *) &address,  sizeof(struct sockaddr_un)) != 0)
       {
        printf("bind() failed\n");
        return 1;
       }
       if(listen(socket_fd, 5) != 0)
       {
        printf("listen() failed\n");
        return 1;
       }
       while((connection_fd = accept(socket_fd, (struct sockaddr *) &address,   &address_length)) > -1)
       {
        child = fork();
        if(child == 0)
        {  /* now inside newly created connection handling process */
         return connection_handler(connection_fd);
        }/* still inside server process */
        close(connection_fd);
       }
       close(socket_fd);
       unlink("./demo_socket");
       return 0;
      }


Posted by at No comments:
Subscribe to: Posts (Atom)