NETWORK AND SYSTEM PROGRAMMING

Transcription

1 NETWORK AND SYSTEM PROGRAMMING Objectives: IPC using PIPE IPC using FIFO LAB 06 IPC(Inter Process Communication) PIPE: A pipe is a method of connecting the standard output of one process to the standard input of another. One of the fundamental features that make Linux and other Unices useful is the pipe. Pipes allow separate processes to communicate without having been designed explicitly to work together. This allows tools quite narrow in their function to be combined in complex ways. This direct connection between programs allows them to operate simultaneously and permits data to be transferred between them continuously rather than having to pass it through temporary text files or through the display screen and having to wait for one program to be completed before the next program begins. Command Line Use of PIPE: Connect standard output of a command to standard input of another Use the pipe operator Syntax: cmd1 cmd2 cmdn EXAMPLE 1: The following example employs a pipe to combine the ls and the wc (i.e., word count) commands in order to show how many filesystem objects (i.e., files, directories and links) are in the current directory: $ ls wc -l ls lists each object, one per line, and this list is then piped to wc, which, when used with its -l option, counts the number of lines and writes the result to standard output. The output could be redirected to a file named, for instance, count.txt:

2 $ ls wc -l > count.txt The output redirection operator will create count.txt if it does not exist or overwrite it if it already exists. And the output will be redirected to it. EXAMPLE 2: $ps -A grep init This command line takes the output of the ps -A command, which lists all running processes, and pipes it with the pipe symbol to the grep init command, which returns all lines that were passed to it that contain the string init. (grep Linux command is use to search files for a word and text string). LAB TASK 1 Create files and name students.txt, pstudent.txt and fstudents.txt. Enter student s names in pstudent.txt and fstudent.txt. After that append the file students.txt with first five sorted names from pstudent.txt and last five sorted names from fstudent.txt. (USING PIPES) PIPE in C Programming: Creating pipelines with the C programming language can be a bit more involved than our simple shell example. To create a simple pipe with C, we make use of the pipe() system call. It takes a single argument, which is an array of two integers, If successful, the array will contain two new file descriptors to be used for the pipeline. After creating a pipe, the process typically spawns a new process (remember the child inherits open file descriptors). System call: pipe(); Prototype: int pipe(int fd[2] ); Returns: 0 on success -1 on error NOTE: fd[0] is set up for reading fd[1] is set up for writing

3 The first integer in the array (element 0) is set up and opened for reading, while the second integer (element 1) is set up and opened for writing. Visually speaking, the output of fd1 becomes the input for fd0. IMPORTANT SYSTEM CALLS: pipe, read, write, close pipe: Create a pipe for IPC read: Read from a pipe write: Write data to a pipe close: Close/destroy a pipe LAB TASK 2 Execute and examine the code (implementation of PIPE). Implementation of pipe() /* Parent creates pipe, forks a child, child writes into pipe, and parent reads from pipe */ #include <stdio.h> #include <sys/types.h> #include <sys/wait.h> #include <string.h> main() int pipefd[2], pid, n, rc, nr, status; char *teststring = "Hello, world!\n", buf[1024]; rc = pipe (pipefd); if (rc < 0) perror("pipe"); pid = fork (); if (pid < 0) perror("fork");

4 if (pid == 0) /* Child s Code */ close(pipefd[0]); write(pipefd[1], teststring, strlen(teststring)); close(pipefd[1]); /* Parent s Code */ else close(pipefd[1]); n = strlen(teststring); nr = read(pipefd[0], buf, n); rc = write(1, buf, nr); wait(&status); printf("good work child!\n"); return(0); FIFO (Named PIPE) : Pipes are commonly used for inter process communication. Major disadvantage of pipes: They can be used only by one process (there are readers and writers within the same process) or the processes which share the same file descriptor table (normally the processes and the child processes or threads created by them). They cannot pass information between unrelated processes. This is because they do not share the same file descriptor table. But if names are given to the pipes, then one would be able to read or write data to them just like a normal file. The processes need not even share anything with each other FIFO (First In First Out) are also called named pipes. Main features of FIFO are: It implements FIFO feature of the pipes They can be opened just like normal files using their names Data can be read from or written to the FIFO. A named pipe works much like a regular pipe, but does have some noticeable differences. Named pipes exist as a device special file in the file system. When all I/O is done by sharing processes, the named pipe remains in the file system for later use.

5 Command Line Use of FIFO: $ mkfifo: Creates fifo- the named pipes Syntax: mkfifo [options] fifo_name $ mkfifo fifo There is one more way by which we can FIFO using mknod. mknod is used to create block or character special files. $ mknod [OPTION]... fifo_name TYPE To create a FIFO fifo1: $ mknod fifo1 p Where p corresponds to file type: pipe (remember FIFO is a named pipe). Reading/ Writing data from/to a FIFO: Let s open two terminals 1. In the first terminal write: $ cat > fifo 2. Open 2 nd terminal and write: $ cat fifo LAB TASK 3 3. Now keep on writing to the first terminal. You will notice that every time you press enter, the corresponding line appears in the second terminal. Pressing CTRL+D in the first terminal terminates writing to the fifo. This also terminates the second process because reading from the fifo now generates a BROKEN PIPE signal. The default action for this is to terminate the process. Examine the details of the file fifo $ ls -l fifo $ stat fifo If you notice carefully, FIFOs just like a normal file possess all the details like inode number, the number of links to it, the access, modification times, size and the access permissions.

6 LAB TASK 4 Implement the following commands and find the effect of using fifo. FIFO in C Programming: Created with mknod() or mkfifo() system call mkfifo Library Call: #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *path, mode_t mode); mode sets permission on FIFO Calls mknod mknod System Call #include <sys/types.h> #include <sys/stat.h> int mknod (const char *path, mode_t mode, dev_t dev); mode should be permission mode OR-ed with S_IFIFO dev is set to 0 for a FIFO RETURNS: 0 on success -1 on error

7 mknod("/tmp/myfifo", S_IFIFO 0666, 0); In this case, the file /tmp/myfifo is created as a FIFO file. The requested permissions are LAB TASK 5 What output is generated by executing server and client codes and how? a) First Example SERVER: #include<stdio.h> #include<unistd.h> #include<fcntl.h> #include<sys/types.h> #include<sys/stat.h> #include<string.h> int main() char fname[25]=""; char fcontent[100]=""; int fd,fd1,fd2; mkfifo("fifo1",0600); mkfifo("fifo2",0600); fd=open("fifo1",o_rdonly); fd1=open("fifo2",o_wronly); read(fd,fname,25); fd2=open(fname,o_rdonly); while(read(fd2,fcontent,100)!=0) printf("%s\n",fcontent); if(fd<0) write(fd1,"file not exit",14); else write(fd1,fcontent,strlen(fcontent)); close(fd); close(fd1); close(fd2); CLIENT: #include<stdio.h> #include<unistd.h> #include<fcntl.h> #include<sys/types.h> #include<sys/stat.h> #include<string.h> int main() char s[100]=""; char s1[1000]=""; int fd,fd1; fd=open("fifo1",o_wronly); fd1=open("fifo2",o_rdonly); printf("\nenter the file name:"); scanf("%s",s); write(fd,s,strlen(s)); while(read(fd1,s1,1000)!=0) printf("file Content :%s",s1); NOTE: Open two terminals Compile and execute server code on first terminal Compile and execute client code on 2 nd terminal.

8 b) 2nd Example: Read MSG1 Write MSG1 Write MSG2 Read MSG2 MSG1 MSG2 SERVER CODE: #include <stdio.h> #include <string.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/errno.h> extern int errno; #define FIFO1 "/tmp/fifo.1" #define FIFO3 "/tmp/fifo.3" #define PERMS 0666 #define MESSAGE1 "Hello, world!\n" #define MESSAGE2 "Hello, class!\n" main() char buff[bufsiz]; int readfd, writefd; int n, size; if ((mknod (FIFO1, S_IFIFO PERMS, 0) < 0) && (errno!= EEXIST)) perror ("mknod FIFO1"); if (mkfifo(fifo3, PERMS) < 0) unlink (FIFO1); perror("mknod FIFO3"); if ((readfd = open(fifo1, 0)) < 0) perror ("open FIFO1"); if ((writefd = open(fifo3, 1)) < 0) perror ("open FIFO3"); size = strlen(message1) + 1; if ((n = read(readfd, buff, size)) < 0) perror ("server read"); exit (1);

9 if (write (1, buff, n) < n) perror("server write1"); exit (1); size = strlen(message2) + 1; if (write (writefd, MESSAGE2, size)!= size) perror ("server write2"); exit (1); close (readfd); close (writefd); CLIENT CODE: #include <stdio.h> #include <string.h> #include<stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/errno.h> extern int errno; #define FIFO1 "/tmp/fifo.1" #define FIFO3 "/tmp/fifo.3" #define PERMS 0666 #define MESSAGE1 "Hello, world!\n" #define MESSAGE2 "Hello, class!\n" main() char buff[bufsiz]; int readfd, writefd, n, size; if ((writefd = open(fifo1, 1)) < 0) perror ("client open FIFO1"); if ((readfd = open(fifo3, 0)) < 0) perror ("client open FIFO3"); size = strlen(message1) + 1; if (write(writefd, MESSAGE1, size)!= size) perror ("client write1"); if ((n = read(readfd, buff, size)) < 0) perror ("client read"); else if (write(1, buff, n)!= n) perror ("client write2"); close(readfd); close(writefd); /* Remove FIFOs now that we are done using them */ if (unlink (FIFO1) < 0) perror("client unlink FIFO1"); if (unlink (FIFO3) < 0)

10 perror("client unlink FIFO3"); exit(0);