Named and nonamed pipes examples.

Author: Anton Yarkov

multithreading/03 - Nonamed_pipes.cpp

@@ -0,0 +1,132 @@
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+using namespace std;
+
+struct CmdLine
+{
+    char* value;
+    char* arguments;
+    CmdLine* next;
+};
+
+// Compilation:
+// g++ "03 - Nonamed_pipes.cpp" -o nonamedpipes
+
+// Task:
+// Create a program which works just like the command below:
+// $> who | sort | uniq -c | sort -nk1
+
+void run(CmdLine* command)
+{
+    const int numPipes = 3;
+    int i = 0;
+    pid_t pid;
+
+    // Create all pipes.
+    int pipefds[2*numPipes];
+    for(i = 0; i < (numPipes); i++)
+    {
+        if(pipe(pipefds + i*2) < 0)
+        {
+            printf("Couldn't create pipe %d\n", i + 1);
+            exit(EXIT_FAILURE);
+        }
+    }
+    
+    int j = 0;
+    while(command)
+    {
+        pid = fork();
+        if(pid == 0)
+        {
+            //if not last command
+            if(command->next)
+            {
+                if(dup2(pipefds[j + 1], STDOUT_FILENO) < 0)
+                {
+                    perror("dup2");
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+            //if not first command && j != 2*numPipes
+            if(j != 0 )
+            {
+                if(dup2(pipefds[j-2], STDIN_FILENO) < 0)
+                {
+                    perror(" dup2");///j-2 0 j+1 1
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+
+            for(i = 0; i < 2*numPipes; i++)
+            {
+                close(pipefds[i]);
+            }
+            
+            // Command with or without arguments.
+            if (command->arguments == NULL)
+            {
+                if( execlp(command->value, command->value, NULL) < 0 )
+                {
+                    perror(command->value);
+                    exit(EXIT_FAILURE);
+                }
+            }
+            else
+            {
+                if( execlp(command->value, command->value, command->arguments, NULL) < 0 )
+                {
+                    perror(command->value);
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+        else if(pid < 0)
+        {
+            perror("error");
+            exit(EXIT_FAILURE);
+        }
+
+        command = command->next;
+        j+=2;
+    }
+    
+    /* Parent closes the pipes and wait for children */
+    for(i = 0; i < 2 * numPipes; i++)
+    {
+        close(pipefds[i]);
+    }
+
+    int status;
+    for(i = 0; i < numPipes + 1; i++)
+    {
+        wait(&status);
+    }
+}
+
+int main(int argc, char** argv)
+{
+    printf("Result of operation is the same like if you type\n$>who | sort | uniq -c | sort -nk1\n");
+    
+    char sort[] = "sort";
+    char sortArg[] = "-nk1";
+    char uniq[] = "uniq";
+    char uniqArg[] = "-c";
+    char who[] = "who";
+    
+    CmdLine command4 = { sort, sortArg, NULL };
+    CmdLine command3 = { uniq, uniqArg, &command4 };
+    CmdLine command2 = { sort, NULL, &command3 };
+    CmdLine command1 = { who, NULL, &command2 };
+    
+    run(&command1);
+    
+    return 0;
+}

multithreading/03 - Nonamed_pipes_read_write.c

@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#define EXIT_FAILURE 1
+
+// Compilation:
+// gcc "03 - Nonamed_pipes_read_write.c" -o nonamedpipesrw
+
+// Task:
+// Do write on one end and read on another end.
+
+void main()
+{
+    int     fd[2], nbytes;
+    pid_t   childpid;
+    char    string[] = "Hello, world!\n";
+    char    readbuffer[80];
+
+    pipe(fd);
+    
+    printf("Process %d creates child\n", getpid());
+            
+    if((childpid = fork()) == -1)
+    {
+        perror("fork");
+        exit(EXIT_FAILURE);
+    }
+
+    if(childpid == 0)
+    {
+        /* Child process closes up input side of pipe */
+        close(fd[0]);
+
+        /* Send "string" through the output side of pipe */
+        write(fd[1], string, (strlen(string)+1));
+        printf("Done write in process %d\n", getpid());
+        exit(0);
+    }
+    else
+    {
+        /* Parent process closes up output side of pipe */
+        close(fd[1]);
+
+        /* Read in a string from the pipe */
+        nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
+        printf("Received string: %s in process %d\n", readbuffer, getpid());
+    }
+    
+    exit(0);
+}

multithreading/03 - Nonamed_pipes_wc_logins.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <unistd.h>
+
+// Compilation:
+// gcc "03 - Nonamed_pipes_wc_logins.c" -o nonamedpipeslogins
+
+// Task:
+// Create a program which works just like the command
+// $> who | wc -l
+
+// Help:
+// Create pipe: who -> stdout -> [pfd[1] -> pfd[0]] -> stdin -> wc -l
+void main()
+{
+    printf("Result of operation is the same like if you type\n$>who | wc -l\n");
+    
+    int pfd[2];
+
+    pipe(pfd);
+
+    if (!fork())
+    {
+        // Since descriptors are shared between the parent and child,
+        // we should always be sure to close the end of pipe we aren't concerned with.
+        // On a technical note, the EOF will never be returned
+        // if the unnecessary ends of the pipe are not explicitly closed.
+        close(STDOUT_FILENO);
+        dup2(pfd[1], STDOUT_FILENO);
+        close(pfd[1]);
+        close(pfd[0]);
+        execlp("who", "who", NULL);
+    }
+    else
+    {
+        close(STDIN_FILENO);
+        dup2(pfd[0], STDIN_FILENO);
+        close(pfd[1]);
+        close(pfd[0]);
+        execlp("wc", "wc", "-l", NULL);
+    }
+    exit(0);
+}

multithreading/04 - Named_pipes.c

@@ -0,0 +1,59 @@
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define EXIT_FAILURE 1
+
+// Compilation:
+// gcc "04 - Named_pipes.c" -o namedpipes
+
+// Task:
+// Create Named Pipe aka FIFO to do write on one end and read on another end.
+
+void main()
+{
+    char * myfifo = "/tmp/myfifo";
+    mkfifo(myfifo, 0666);
+    
+            
+    pid_t childpid;
+    if((childpid = fork()) == -1)
+    {
+        perror("fork");
+        exit(EXIT_FAILURE);
+    }
+
+    if(childpid == 0)
+    {
+        char string[] = "Hello, world!";
+        int fd;
+        if (fd = open(myfifo, O_WRONLY))
+        {
+            write(fd, string, (strlen(string)+1));
+            close(fd);
+        }
+
+        printf("Process %d done write and unlink fifo.\n", getpid());
+        unlink(myfifo);
+    }
+    else
+    {
+        printf("Process %d creates child %d\n", getpid(), childpid);
+        
+        char readbuffer[80];
+        int fd;
+        if (fd = open(myfifo, O_RDONLY))
+        {
+            read(fd, readbuffer, 80);            
+            printf("Process %d received string: %s\n", getpid(), readbuffer);
+            close(fd);
+        }
+        unlink(myfifo);
+    }
+    
+    exit(0);
+}