pipe - hochan222/Everything-in-JavaScript GitHub Wiki

#include <stdio.h>

FILE *popen(const char *command, const char *mode);

#include <stdio.h>

int pclose(FILE *stream);

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

int main(void) {
    FILE *fp;
    int a;

    fp = popen("wc -l", "w");
    if(fp == NULL) {
        fprintf(stderr, "popen failed\n");
        exit(1);
    }

    for(a=0; a<100; a++)
        fprintf(fp, "test line\n");

    pclose(fp);

    return 0;
}

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

int main(void) {
    FILE *fp;
    char buf[256];

    fp = popen("date", "r"); // 자식 프로세스에서는 date 명령을 수행.
    if(fp == NULL) {
        fprintf(stderr, "popen failed\n");
        exit(1);
    }
    // 부모 프로세스에서는 14행에서 자식 프로세스가 기록한 데이터를 읽고
    // 저장해  20행에서 출력한다.
    if(fgets(buf, sizeof(buf), fp) == NULL) {
        fprintf(stderr, "No data from pipe!\n");
        exit(1);
    }

    printf("line : %s\n", buf);
    pclose(fp);

    return 0;
}

#include <unistd.h>

int pipe(int fildes[2]);

#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int fd[2];
    pid_t pid;
    char buf[257];
    int len, status;

    if(pipe(fd) == -1) { // pipe 함수를 사용해 파이프를 생성한다. pipe 함수의 인자로는 파일 기술자를 저장할 배열을 지정한다.
        perror("pipe");
        exit(1);
    }

    switch(pid = fork()) { // fork 함수를 사용해 자식 프로세스를 생성한다.
        case -1:
            perror("fork");
            exit(1);
            break;
        // 자식 프로세스의 동작 부분이다. 24행에서 fd[1]을 닫는다. 이는 자식 프로세스에서
        // 파이프를 읽기용으로 사용하겠다는 의미다. 27행에서 파이프의 입력 부분인 fd[0]에서
        // 문자열을 읽어들인다.
        case 0: /* child */
            close(fd[1]);
            write(1, "Child Process:", 15);
            len = read(fd[0], buf, 256);
            write(1, buf, len);
            close(fd[0]);
            break;
        // 부모 프로세스의 동작 부분이다. 34행에서 fd[0]을 닫는다. 이는 파이프를
        // 출력용으로 사용하겠다는 의미다. 37행에서 fd[1]로 문자열을 출력한다.
        default:
            close(fd[0]);
            buf[0] = '\0';
            write(fd[1], "Test Message\n", 14);
            close(fd[1]);
            waitpid(pid, &status, 0);
            break;
    }

    return 0;
}

#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int fd[2];
    pid_t pid;

    if(pipe(fd) == -1) {  // 파이프를 생성한다.
        perror("pipe");
        exit(1);
    }

    // fork 함수를 사용해 자식 프로세스를 생성한다. pas 명령의 결과는
    // 기본으로 표준 출력으로 출력되고, grep 명령은 표준 입력을 통해
    // 입력받는다. 따라서 부모 프로세스와 자식 프로세스 간의 통신이
    // 표준 입출력 대신 파이프를 통해 이루어지도록 만들어야 한다.
    switch(pid = fork()) {
        case -1:
            perror("fork");
            exit(1);
            break;
        case 0: /* child */
            // 자식 프로세스가 해야 할 일은 부모 프로세스가 파이프로 출력하는
            // ps -ef 명령의 결과를 받아 grep telnet 명령을 수행하는 것이다.
            // 따라서 파이프의 출력 부분이 필요없으므로 fd[1]을 닫는다.
            close(fd[1]); // 읽기용으로 사용
            // fd[0]의 값이 0이 아니면, 즉 표준 입력이 아니면 fd[0]의 값을
            // 표준 입력으로 복사 한 후 fd[0]을 닫느다. 이제 자식 프로세스에서는
            // 표준 입력을 fd[0]이 가리키는 파이프에서 읽는다.
            if(fd[0] != 0) {
                dup2(fd[0], 0);
                close(fd[0]);
            }
            // 자식 프로세스가 grep 명령을 exec 함수로 호출한다. 이렇게 하면 grep 명령은
            // 표준 입력을 통해 데이터를 읽어들이려 한다. 이미 위쪽에 표준 입력으로 파이프의
            // 입력 파일 기술자를 복사했으므로 결과적으로 파이프를 통해 데이터를 읽어들인다.
            execlp("grep", "grep", "telnet", (char *)NULL);
            exit(1);
            break;
        default:
            // 부모 프로세스의 동작을 살펴보면 자식 프로세스와 크게 다를 것이 없음을 알 수 있다.
            // 우선 파이프의 입력 부분이 필요 없으므로 닫느다.
            close(fd[0]);
            // 파이프의 출력 부분을 표준 출력으로 복사한다. 따라서 부모 프로세스에서
            // 무언가를 출력하면, 파이프를 통해 출력된다.
            if(fd[1] != 1) {
                dup2(fd[1], 1);
                close(fd[1]);
            }
            // exec 함수를 사용해 ps -ef 명령을 실행한다. ps -ef의 명령은 기본으로 표준 출력으로
            // 출력하므로 결과가 파이프로 출력된다. 이 출력 결과를 자식 프로세스가 읽어 들인다.
            execlp("ps", "ps", "-ef", (char *)NULL);
            wait(NULL);
            break;
    }

    return 0;
}

#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    int fd1[2], fd2[2];
    pid_t pid;
    char buf[257];
    int len, status;

    // 파이프를 하나 생성한다. 생성된 파일 기술자 fd1은 부모 프로세스에서
    // 자식 프로세스로 데이터를 보낼때 사용한다.
    if(pipe(fd1) == -1) {
        perror("pipe");
        exit(1);
    }

    // 또 다른 파이프를 생성한다. 파일 기술자 fd2는 자식 프로세스에서
    // 부모 프로세스로 데이터를 보낼때 사용한다.
    if(pipe(fd2) == -1) {
        perror("pipe");
        exit(1);
    }

    switch(pid = fork()) {
        case -1:
            perror("fork");
            exit(1);
            break;
        // 자식 프로세스는 부모 프로세스에서 오는 데이터를 읽는 데 사용할
        // fd1[0]을 남겨두고 fd1[1]을 닫느다. 또한 부모 프로세스로 데이터를 보내는데
        // 사용할 fd2[1]을 남겨두고 fd2[0]을 닫느다.
        case 0: /* child */
            close(fd1[1]);
            close(fd2[0]);
            write(1, "Child Process:", 15);
            len = read(fd1[0], buf, 256); // 부모프로세스로 부터 읽어온다.
            write(1, buf, len);
            strcpy(buf, "Good\n");
            write(fd2[1], buf, strlen(buf)); //자식 프로세스가 부모에게
            break;
        // 부모 프로세스는 자식 프로세스와 반대다. 자식 프로세스에 데이터를 보내는데 사용할 fd[1]을
        // 남겨두고, 자식 프로세스에서 오는 데이터를 읽는 데 사용할 fd2[0]을 남겨둔다.
        default:
            close(fd1[0]);
            close(fd2[1]);
            buf[0] = '\0';
            write(fd1[1], "Hello\n", 6); // 부모프로세스가 자식 프로세스에게
            sleep(2);
            write(1, "Parent Process:", 15);
            len = read(fd2[0], buf, 256); //자식프로세스로부터 읽어온다.
            write(1, buf, len);
            waitpid(pid, &status, 0);
            break;
    }

    return 0;
}